blob: b0d373bd322b581faae2ea752d03bbf7167edca6 [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"
Mathieu Chartier7469ebf2012-09-24 16:28:36 -070033#include "gc/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"
Ian Rogers50b35e22012-10-04 10:09:15 -070037#include "thread.h"
Elliott Hughes601a1232012-02-02 17:47:38 -080038#include "timing_logger.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -070039#include "verifier/method_verifier.h"
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070040
Elliott Hughes059d5c12012-03-12 17:39:18 -070041#if defined(__APPLE__)
42#include <mach-o/dyld.h>
43#endif
44
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070045namespace art {
46
Ian Rogers996cc582012-02-14 22:23:29 -080047static double Percentage(size_t x, size_t y) {
Elliott Hughes398f64b2012-03-26 18:05:48 -070048 return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
Ian Rogers996cc582012-02-14 22:23:29 -080049}
50
51static void DumpStat(size_t x, size_t y, const char* str) {
52 if (x == 0 && y == 0) {
53 return;
54 }
55 LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
56}
57
Ian Rogersc8b306f2012-02-17 21:34:44 -080058class AOTCompilationStats {
59 public:
Ian Rogersca190662012-06-26 15:45:57 -070060 AOTCompilationStats()
61 : stats_lock_("AOT compilation statistics lock"),
62 types_in_dex_cache_(0), types_not_in_dex_cache_(0),
63 strings_in_dex_cache_(0), strings_not_in_dex_cache_(0),
64 resolved_types_(0), unresolved_types_(0),
65 resolved_instance_fields_(0), unresolved_instance_fields_(0),
66 resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0) {
Ian Rogers2ed3b952012-03-17 11:49:39 -070067 for (size_t i = 0; i <= kMaxInvokeType; i++) {
Ian Rogersc8b306f2012-02-17 21:34:44 -080068 resolved_methods_[i] = 0;
69 unresolved_methods_[i] = 0;
Ian Rogers2ed3b952012-03-17 11:49:39 -070070 virtual_made_direct_[i] = 0;
71 direct_calls_to_boot_[i] = 0;
72 direct_methods_to_boot_[i] = 0;
Elliott Hughesb25c3f62012-03-26 16:35:06 -070073 }
Ian Rogersc8b306f2012-02-17 21:34:44 -080074 }
75
76 void Dump() {
77 DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache");
78 DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache");
79 DumpStat(resolved_types_, unresolved_types_, "types resolved");
80 DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved");
81 DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_,
82 "static fields resolved");
83 DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_,
84 "static fields local to a class");
85
Ian Rogers2ed3b952012-03-17 11:49:39 -070086 for (size_t i = 0; i <= kMaxInvokeType; i++) {
Ian Rogersc8b306f2012-02-17 21:34:44 -080087 std::ostringstream oss;
Ian Rogers2ed3b952012-03-17 11:49:39 -070088 oss << static_cast<InvokeType>(i) << " methods were AOT resolved";
Ian Rogersc8b306f2012-02-17 21:34:44 -080089 DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str());
Ian Rogers2ed3b952012-03-17 11:49:39 -070090 if (virtual_made_direct_[i] > 0) {
91 std::ostringstream oss2;
92 oss2 << static_cast<InvokeType>(i) << " methods made direct";
93 DumpStat(virtual_made_direct_[i],
94 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i],
95 oss2.str().c_str());
96 }
97 if (direct_calls_to_boot_[i] > 0) {
98 std::ostringstream oss2;
99 oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot";
100 DumpStat(direct_calls_to_boot_[i],
101 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i],
102 oss2.str().c_str());
103 }
104 if (direct_methods_to_boot_[i] > 0) {
105 std::ostringstream oss2;
106 oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot";
107 DumpStat(direct_methods_to_boot_[i],
108 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i],
109 oss2.str().c_str());
110 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800111 }
112 }
Ian Rogers996cc582012-02-14 22:23:29 -0800113
Ian Rogers50b35e22012-10-04 10:09:15 -0700114// Allow lossy statistics in non-debug builds.
Ian Rogers996cc582012-02-14 22:23:29 -0800115#ifndef NDEBUG
Ian Rogers50b35e22012-10-04 10:09:15 -0700116#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_)
Ian Rogers996cc582012-02-14 22:23:29 -0800117#else
118#define STATS_LOCK()
119#endif
120
Ian Rogersc8b306f2012-02-17 21:34:44 -0800121 void TypeInDexCache() {
122 STATS_LOCK();
123 types_in_dex_cache_++;
Ian Rogers996cc582012-02-14 22:23:29 -0800124 }
Ian Rogers996cc582012-02-14 22:23:29 -0800125
Ian Rogersc8b306f2012-02-17 21:34:44 -0800126 void TypeNotInDexCache() {
127 STATS_LOCK();
128 types_not_in_dex_cache_++;
Ian Rogers996cc582012-02-14 22:23:29 -0800129 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800130
131 void StringInDexCache() {
132 STATS_LOCK();
133 strings_in_dex_cache_++;
134 }
135
136 void StringNotInDexCache() {
137 STATS_LOCK();
138 strings_not_in_dex_cache_++;
139 }
140
141 void TypeDoesntNeedAccessCheck() {
142 STATS_LOCK();
143 resolved_types_++;
144 }
145
146 void TypeNeedsAccessCheck() {
147 STATS_LOCK();
148 unresolved_types_++;
149 }
150
151 void ResolvedInstanceField() {
152 STATS_LOCK();
153 resolved_instance_fields_++;
154 }
155
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700156 void UnresolvedInstanceField() {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800157 STATS_LOCK();
158 unresolved_instance_fields_++;
159 }
160
161 void ResolvedLocalStaticField() {
162 STATS_LOCK();
163 resolved_local_static_fields_++;
164 }
165
166 void ResolvedStaticField() {
167 STATS_LOCK();
168 resolved_static_fields_++;
169 }
170
171 void UnresolvedStaticField() {
172 STATS_LOCK();
173 unresolved_static_fields_++;
174 }
175
176 void ResolvedMethod(InvokeType type) {
177 DCHECK_LE(type, kMaxInvokeType);
178 STATS_LOCK();
179 resolved_methods_[type]++;
180 }
181
182 void UnresolvedMethod(InvokeType type) {
183 DCHECK_LE(type, kMaxInvokeType);
184 STATS_LOCK();
185 unresolved_methods_[type]++;
186 }
187
Ian Rogers2ed3b952012-03-17 11:49:39 -0700188 void VirtualMadeDirect(InvokeType type) {
189 DCHECK_LE(type, kMaxInvokeType);
Ian Rogersfb6adba2012-03-04 21:51:51 -0800190 STATS_LOCK();
Ian Rogers2ed3b952012-03-17 11:49:39 -0700191 virtual_made_direct_[type]++;
Ian Rogersfb6adba2012-03-04 21:51:51 -0800192 }
Ian Rogers2ed3b952012-03-17 11:49:39 -0700193
194 void DirectCallsToBoot(InvokeType type) {
195 DCHECK_LE(type, kMaxInvokeType);
196 STATS_LOCK();
197 direct_calls_to_boot_[type]++;
198 }
199
200 void DirectMethodsToBoot(InvokeType type) {
201 DCHECK_LE(type, kMaxInvokeType);
202 STATS_LOCK();
203 direct_methods_to_boot_[type]++;
204 }
205
Ian Rogersc8b306f2012-02-17 21:34:44 -0800206 private:
207 Mutex stats_lock_;
208
209 size_t types_in_dex_cache_;
210 size_t types_not_in_dex_cache_;
211
212 size_t strings_in_dex_cache_;
213 size_t strings_not_in_dex_cache_;
214
215 size_t resolved_types_;
216 size_t unresolved_types_;
217
218 size_t resolved_instance_fields_;
219 size_t unresolved_instance_fields_;
220
221 size_t resolved_local_static_fields_;
222 size_t resolved_static_fields_;
223 size_t unresolved_static_fields_;
224
225 size_t resolved_methods_[kMaxInvokeType + 1];
226 size_t unresolved_methods_[kMaxInvokeType + 1];
Ian Rogers2ed3b952012-03-17 11:49:39 -0700227 size_t virtual_made_direct_[kMaxInvokeType + 1];
228 size_t direct_calls_to_boot_[kMaxInvokeType + 1];
229 size_t direct_methods_to_boot_[kMaxInvokeType + 1];
Ian Rogersc8b306f2012-02-17 21:34:44 -0800230
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700231 DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
Ian Rogersc8b306f2012-02-17 21:34:44 -0800232};
Ian Rogers996cc582012-02-14 22:23:29 -0800233
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800234static std::string MakeCompilerSoName(InstructionSet instruction_set) {
235 // TODO: is the ARM/Thumb2 instruction set distinction really buying us anything,
236 // or just causing hassle like this?
237 if (instruction_set == kThumb2) {
238 instruction_set = kArm;
239 }
240
Brian Carlstrom5644f002012-06-27 23:05:17 -0700241 // Lower case the instruction set, because that's what we do in the build system.
Elliott Hughes6fcce302012-06-19 16:54:19 -0700242 std::string instruction_set_name(ToStr<InstructionSet>(instruction_set).str());
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800243 for (size_t i = 0; i < instruction_set_name.size(); ++i) {
Brian Carlstrom5644f002012-06-27 23:05:17 -0700244 instruction_set_name[i] = tolower(instruction_set_name[i]);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800245 }
Elliott Hughes059d5c12012-03-12 17:39:18 -0700246
247 // Bad things happen if we pull in the libartd-compiler to a libart dex2oat or vice versa,
248 // because we end up with both libart and libartd in the same address space!
Elliott Hughes67d92002012-03-26 15:08:51 -0700249 const char* suffix = (kIsDebugBuild ? "d" : "");
Elliott Hughes059d5c12012-03-12 17:39:18 -0700250
251 // Work out the filename for the compiler library.
Shih-wei Liaoe94d9b22012-05-22 09:01:24 -0700252#if defined(ART_USE_LLVM_COMPILER)
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800253 std::string library_name(StringPrintf("art%s-compiler-llvm", suffix));
Shih-wei Liaoe94d9b22012-05-22 09:01:24 -0700254#elif defined(ART_USE_GREENLAND_COMPILER)
255 std::string library_name(StringPrintf("art%s-compiler-greenland", suffix));
256#else
257 std::string library_name(StringPrintf("art%s-compiler-%s", suffix, instruction_set_name.c_str()));
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800258#endif
Elliott Hughes059d5c12012-03-12 17:39:18 -0700259 std::string filename(StringPrintf(OS_SHARED_LIB_FORMAT_STR, library_name.c_str()));
260
261#if defined(__APPLE__)
262 // On Linux, dex2oat will have been built with an RPATH of $ORIGIN/../lib, so dlopen(3) will find
263 // the .so by itself. On Mac OS, there isn't really an equivalent, so we have to manually do the
264 // same work.
Elliott Hughes059d5c12012-03-12 17:39:18 -0700265 uint32_t executable_path_length = 0;
Elliott Hughes448e93c2012-03-28 22:30:06 -0700266 _NSGetExecutablePath(NULL, &executable_path_length);
267 std::string path(executable_path_length, static_cast<char>(0));
268 CHECK_EQ(_NSGetExecutablePath(&path[0], &executable_path_length), 0);
Elliott Hughes059d5c12012-03-12 17:39:18 -0700269
270 // Strip the "/dex2oat".
271 size_t last_slash = path.find_last_of('/');
272 CHECK_NE(last_slash, std::string::npos) << path;
273 path.resize(last_slash);
274
275 // Strip the "/bin".
276 last_slash = path.find_last_of('/');
277 path.resize(last_slash);
278
279 filename = path + "/lib/" + filename;
280#endif
281 return filename;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800282}
283
Elliott Hughes46f060a2012-03-09 17:36:50 -0800284template<typename Fn>
285static Fn FindFunction(const std::string& compiler_so_name, void* library, const char* name) {
286 Fn fn = reinterpret_cast<Fn>(dlsym(library, name));
287 if (fn == NULL) {
288 LOG(FATAL) << "Couldn't find \"" << name << "\" in compiler library " << compiler_so_name << ": " << dlerror();
289 }
Elliott Hughes059d5c12012-03-12 17:39:18 -0700290 VLOG(compiler) << "Found \"" << name << "\" at " << reinterpret_cast<void*>(fn);
Elliott Hughes46f060a2012-03-09 17:36:50 -0800291 return fn;
292}
293
Elliott Hughes5523ee02012-02-03 18:18:34 -0800294Compiler::Compiler(InstructionSet instruction_set, bool image, size_t thread_count,
Brian Carlstromba0668e2012-03-26 13:14:07 -0700295 bool support_debugging, const std::set<std::string>* image_classes,
296 bool dump_stats, bool dump_timings)
Brian Carlstromaded5f72011-10-07 17:15:04 -0700297 : instruction_set_(instruction_set),
Elliott Hughesc225caa2012-02-03 15:43:37 -0800298 compiled_classes_lock_("compiled classes lock"),
299 compiled_methods_lock_("compiled method lock"),
300 compiled_invoke_stubs_lock_("compiled invoke stubs lock"),
Logan Chien7a2a23a2012-06-06 11:01:00 +0800301#if defined(ART_USE_LLVM_COMPILER)
302 compiled_proxy_stubs_lock_("compiled proxy stubs lock"),
303#endif
Brian Carlstromaded5f72011-10-07 17:15:04 -0700304 image_(image),
Elliott Hughes5523ee02012-02-03 18:18:34 -0800305 thread_count_(thread_count),
Elliott Hughesde6e4cf2012-02-27 14:46:06 -0800306 support_debugging_(support_debugging),
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700307 start_ns_(0),
Ian Rogersc8b306f2012-02-17 21:34:44 -0800308 stats_(new AOTCompilationStats),
Brian Carlstromba0668e2012-03-26 13:14:07 -0700309 dump_stats_(dump_stats),
310 dump_timings_(dump_timings),
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800311 image_classes_(image_classes),
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800312 compiler_library_(NULL),
Elliott Hughes46f060a2012-03-09 17:36:50 -0800313 compiler_(NULL),
Elliott Hughes6f4976c2012-03-13 21:19:01 -0700314 compiler_context_(NULL),
Elliott Hughes46f060a2012-03-09 17:36:50 -0800315 jni_compiler_(NULL),
Logan Chien971bf3f2012-05-01 15:47:55 +0800316 create_invoke_stub_(NULL)
317{
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800318 std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800319 compiler_library_ = dlopen(compiler_so_name.c_str(), RTLD_LAZY);
320 if (compiler_library_ == NULL) {
321 LOG(FATAL) << "Couldn't find compiler library " << compiler_so_name << ": " << dlerror();
322 }
323 VLOG(compiler) << "dlopen(\"" << compiler_so_name << "\", RTLD_LAZY) returned " << compiler_library_;
324
buzbee4df2bbd2012-10-11 14:46:06 -0700325 CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, NULL), "compiler tls key");
326
Shih-wei Liaoe94d9b22012-05-22 09:01:24 -0700327#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
Logan Chien106b2a02012-03-18 04:41:38 +0800328 // Initialize compiler_context_
329 typedef void (*InitCompilerContextFn)(Compiler&);
330
331 InitCompilerContextFn init_compiler_context =
332 FindFunction<void (*)(Compiler&)>(compiler_so_name,
333 compiler_library_,
334 "ArtInitCompilerContext");
335
336 init_compiler_context(*this);
buzbee692be802012-08-29 15:52:59 -0700337#elif defined(ART_USE_QUICK_COMPILER)
338 // Initialize compiler_context_
339 typedef void (*InitCompilerContextFn)(Compiler&);
340
341 InitCompilerContextFn init_compiler_context =
342 FindFunction<void (*)(Compiler&)>(compiler_so_name,
343 compiler_library_,
344 "ArtInitQuickCompilerContext");
345
346 init_compiler_context(*this);
Logan Chien106b2a02012-03-18 04:41:38 +0800347#endif
348
Elliott Hughes3fa1b7e2012-03-13 17:06:22 -0700349 compiler_ = FindFunction<CompilerFn>(compiler_so_name, compiler_library_, "ArtCompileMethod");
Elliott Hughes46f060a2012-03-09 17:36:50 -0800350 jni_compiler_ = FindFunction<JniCompilerFn>(compiler_so_name, compiler_library_, "ArtJniCompileMethod");
351 create_invoke_stub_ = FindFunction<CreateInvokeStubFn>(compiler_so_name, compiler_library_, "ArtCreateInvokeStub");
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800352
Logan Chienf7015fd2012-03-18 01:19:37 +0800353#if defined(ART_USE_LLVM_COMPILER)
Logan Chien7a2a23a2012-06-06 11:01:00 +0800354 create_proxy_stub_ = FindFunction<CreateProxyStubFn>(
355 compiler_so_name, compiler_library_, "ArtCreateProxyStub");
Logan Chienf7015fd2012-03-18 01:19:37 +0800356#endif
357
Brian Carlstrom25c33252011-09-18 15:58:35 -0700358 CHECK(!Runtime::Current()->IsStarted());
Brian Carlstromae826982011-11-09 01:33:42 -0800359 if (!image_) {
360 CHECK(image_classes_ == NULL);
361 }
Shih-wei Liaoc486c112011-09-13 16:43:52 -0700362}
363
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700364Compiler::~Compiler() {
Ian Rogers50b35e22012-10-04 10:09:15 -0700365 Thread* self = Thread::Current();
Elliott Hughesc225caa2012-02-03 15:43:37 -0800366 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700367 MutexLock mu(self, compiled_classes_lock_);
Elliott Hughesc225caa2012-02-03 15:43:37 -0800368 STLDeleteValues(&compiled_classes_);
369 }
370 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700371 MutexLock mu(self, compiled_methods_lock_);
Elliott Hughesc225caa2012-02-03 15:43:37 -0800372 STLDeleteValues(&compiled_methods_);
373 }
374 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700375 MutexLock mu(self, compiled_invoke_stubs_lock_);
Elliott Hughesc225caa2012-02-03 15:43:37 -0800376 STLDeleteValues(&compiled_invoke_stubs_);
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800377 }
Brian Carlstromd06dfe72012-06-06 22:15:39 -0700378#if defined(ART_USE_LLVM_COMPILER)
Brian Carlstromf5822582012-03-19 22:34:31 -0700379 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700380 MutexLock mu(self, compiled_proxy_stubs_lock_);
Logan Chien7a2a23a2012-06-06 11:01:00 +0800381 STLDeleteValues(&compiled_proxy_stubs_);
382 }
Brian Carlstromd06dfe72012-06-06 22:15:39 -0700383#endif
Logan Chien7a2a23a2012-06-06 11:01:00 +0800384 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700385 MutexLock mu(self, compiled_methods_lock_);
Brian Carlstromf5822582012-03-19 22:34:31 -0700386 STLDeleteElements(&code_to_patch_);
387 }
388 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700389 MutexLock mu(self, compiled_methods_lock_);
Brian Carlstromf5822582012-03-19 22:34:31 -0700390 STLDeleteElements(&methods_to_patch_);
391 }
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800392#if defined(ART_USE_LLVM_COMPILER)
Logan Chien971bf3f2012-05-01 15:47:55 +0800393 // Uninitialize compiler_context_
394 typedef void (*UninitCompilerContextFn)(Compiler&);
395
396 std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
397
398 UninitCompilerContextFn uninit_compiler_context =
399 FindFunction<void (*)(Compiler&)>(compiler_so_name,
400 compiler_library_,
401 "ArtUnInitCompilerContext");
402
403 uninit_compiler_context(*this);
buzbee692be802012-08-29 15:52:59 -0700404#elif defined(ART_USE_QUICK_COMPILER)
405 // Uninitialize compiler_context_
406 typedef void (*UninitCompilerContextFn)(Compiler&);
407
408 std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
409
410 UninitCompilerContextFn uninit_compiler_context =
411 FindFunction<void (*)(Compiler&)>(compiler_so_name,
412 compiler_library_,
413 "ArtUnInitQuickCompilerContext");
414
415 uninit_compiler_context(*this);
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800416#endif
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800417 if (compiler_library_ != NULL) {
418 VLOG(compiler) << "dlclose(" << compiler_library_ << ")";
buzbeeca7a5e42012-08-20 11:12:18 -0700419#if !defined(ART_USE_QUICK_COMPILER)
420 /*
421 * FIXME: Temporary workaround
422 * Apparently, llvm is adding dctors to atexit, but if we unload
423 * the library here the code will no longer be around at exit time
424 * and we die a flaming death in __cxa_finalize(). Apparently, some
425 * dlclose() implementations will scan the atexit list on unload and
426 * handle any associated with the soon-to-be-unloaded library.
427 * However, this is not required by POSIX and we don't do it.
428 * See: http://b/issue?id=4998315
429 * What's the right thing to do here?
430 */
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800431 dlclose(compiler_library_);
buzbeeca7a5e42012-08-20 11:12:18 -0700432#endif
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800433 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700434}
435
buzbee4df2bbd2012-10-11 14:46:06 -0700436CompilerTls* Compiler::GetTls() {
437 // Lazily create thread-local storage
438 CompilerTls* res = static_cast<CompilerTls*>(pthread_getspecific(tls_key_));
439 if (res == NULL) {
440 res = new CompilerTls();
441 CHECK_PTHREAD_CALL(pthread_setspecific, (tls_key_, res), "compiler tls");
442 }
443 return res;
444}
445
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700446ByteArray* Compiler::CreateResolutionStub(InstructionSet instruction_set,
447 Runtime::TrampolineType type) {
jeffhao7fbee072012-08-24 17:56:54 -0700448 switch (instruction_set) {
449 case kArm:
450 case kThumb2:
451 return arm::ArmCreateResolutionTrampoline(type);
452 case kMips:
453 return mips::MipsCreateResolutionTrampoline(type);
454 case kX86:
455 return x86::X86CreateResolutionTrampoline(type);
456 default:
457 LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
458 return NULL;
Ian Rogersad25ac52011-10-04 19:13:33 -0700459 }
460}
461
Elliott Hughes8add92d2012-01-18 18:18:43 -0800462ByteArray* Compiler::CreateJniDlsymLookupStub(InstructionSet instruction_set) {
Ian Rogers169c9a72011-11-13 20:13:17 -0800463 switch (instruction_set) {
464 case kArm:
465 case kThumb2:
Elliott Hughes8add92d2012-01-18 18:18:43 -0800466 return arm::CreateJniDlsymLookupStub();
jeffhao7fbee072012-08-24 17:56:54 -0700467 case kMips:
468 return mips::CreateJniDlsymLookupStub();
Ian Rogers169c9a72011-11-13 20:13:17 -0800469 case kX86:
Elliott Hughes8add92d2012-01-18 18:18:43 -0800470 return x86::CreateJniDlsymLookupStub();
Ian Rogers169c9a72011-11-13 20:13:17 -0800471 default:
Ian Rogers49c48942012-03-11 15:15:37 -0700472 LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
Ian Rogers169c9a72011-11-13 20:13:17 -0800473 return NULL;
474 }
475}
476
Ian Rogersad25ac52011-10-04 19:13:33 -0700477ByteArray* Compiler::CreateAbstractMethodErrorStub(InstructionSet instruction_set) {
jeffhao7fbee072012-08-24 17:56:54 -0700478 switch (instruction_set) {
479 case kArm:
480 case kThumb2:
481 return arm::CreateAbstractMethodErrorStub();
482 case kMips:
483 return mips::CreateAbstractMethodErrorStub();
484 case kX86:
485 return x86::CreateAbstractMethodErrorStub();
486 default:
487 LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
488 return NULL;
Ian Rogersad25ac52011-10-04 19:13:33 -0700489 }
490}
491
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700492void Compiler::CompileAll(jobject class_loader,
Brian Carlstromae826982011-11-09 01:33:42 -0800493 const std::vector<const DexFile*>& dex_files) {
Brian Carlstrom25c33252011-09-18 15:58:35 -0700494 DCHECK(!Runtime::Current()->IsStarted());
Brian Carlstromae826982011-11-09 01:33:42 -0800495
Elliott Hughes601a1232012-02-02 17:47:38 -0800496 TimingLogger timings("compiler");
497
498 PreCompile(class_loader, dex_files, timings);
499
Ian Rogers3d1548d2012-09-24 14:08:03 -0700500 Compile(class_loader, dex_files, timings);
Elliott Hughes601a1232012-02-02 17:47:38 -0800501
Brian Carlstromba0668e2012-03-26 13:14:07 -0700502 if (dump_timings_ && timings.GetTotalNs() > MsToNs(1000)) {
Elliott Hughes601a1232012-02-02 17:47:38 -0800503 timings.Dump();
504 }
Ian Rogers996cc582012-02-14 22:23:29 -0800505
Brian Carlstromba0668e2012-03-26 13:14:07 -0700506 if (dump_stats_) {
507 stats_->Dump();
508 }
Brian Carlstrom8a487412011-08-29 20:08:52 -0700509}
510
Mathieu Chartier66f19252012-09-18 08:57:04 -0700511void Compiler::CompileOne(const AbstractMethod* method) {
Brian Carlstrom25c33252011-09-18 15:58:35 -0700512 DCHECK(!Runtime::Current()->IsStarted());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700513 Thread* self = Thread::Current();
514 jobject class_loader;
515 const DexCache* dex_cache;
516 const DexFile* dex_file;
517 {
518 ScopedObjectAccessUnchecked soa(self);
519 ScopedLocalRef<jobject>
520 local_class_loader(soa.Env(),
521 soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader()));
522 class_loader = soa.Env()->NewGlobalRef(local_class_loader.get());
523 // Find the dex_file
524 dex_cache = method->GetDeclaringClass()->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -0700525 dex_file = dex_cache->GetDexFile();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700526 }
527 self->TransitionFromRunnableToSuspended(kNative);
Brian Carlstromae826982011-11-09 01:33:42 -0800528
Brian Carlstromae826982011-11-09 01:33:42 -0800529 std::vector<const DexFile*> dex_files;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700530 dex_files.push_back(dex_file);
Brian Carlstromae826982011-11-09 01:33:42 -0800531
Elliott Hughes601a1232012-02-02 17:47:38 -0800532 TimingLogger timings("CompileOne");
533 PreCompile(class_loader, dex_files, timings);
Brian Carlstromae826982011-11-09 01:33:42 -0800534
Ian Rogers0571d352011-11-03 19:51:38 -0700535 uint32_t method_idx = method->GetDexMethodIndex();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700536 const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
Ian Rogers08f753d2012-08-24 14:35:25 -0700537 CompileMethod(code_item, method->GetAccessFlags(), method->GetInvokeType(),
538 method_idx, class_loader, *dex_file);
Brian Carlstromae826982011-11-09 01:33:42 -0800539
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700540 self->GetJniEnv()->DeleteGlobalRef(class_loader);
541
542 self->TransitionFromSuspendedToRunnable();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700543}
544
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700545void Compiler::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
546 TimingLogger& timings) {
Brian Carlstromae826982011-11-09 01:33:42 -0800547 for (size_t i = 0; i != dex_files.size(); ++i) {
548 const DexFile* dex_file = dex_files[i];
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700549 CHECK(dex_file != NULL);
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800550 ResolveDexFile(class_loader, *dex_file, timings);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700551 }
552}
553
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700554void Compiler::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
555 TimingLogger& timings) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800556 Resolve(class_loader, dex_files, timings);
Elliott Hughes601a1232012-02-02 17:47:38 -0800557
Ian Rogers3d1548d2012-09-24 14:08:03 -0700558 Verify(class_loader, dex_files, timings);
Elliott Hughes601a1232012-02-02 17:47:38 -0800559
Ian Rogers3d1548d2012-09-24 14:08:03 -0700560 InitializeClassesWithoutClinit(class_loader, dex_files, timings);
Brian Carlstromae826982011-11-09 01:33:42 -0800561}
562
563bool Compiler::IsImageClass(const std::string& descriptor) const {
564 if (image_classes_ == NULL) {
565 return true;
566 }
567 return image_classes_->find(descriptor) != image_classes_->end();
568}
569
Ian Rogers3d1548d2012-09-24 14:08:03 -0700570void Compiler::RecordClassStatus(ClassReference ref, CompiledClass* compiled_class) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700571 MutexLock mu(Thread::Current(), Compiler::compiled_classes_lock_);
Ian Rogers3d1548d2012-09-24 14:08:03 -0700572 compiled_classes_.Put(ref, compiled_class);
573}
574
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700575bool Compiler::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file,
Ian Rogers996cc582012-02-14 22:23:29 -0800576 uint32_t type_idx) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700577 ScopedObjectAccess soa(Thread::Current());
578 DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800579 if (!IsImage()) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800580 stats_->TypeNotInDexCache();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800581 return false;
582 }
Ian Rogers1bddec32012-02-04 12:27:34 -0800583 Class* resolved_class = dex_cache->GetResolvedType(type_idx);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800584 if (resolved_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800585 stats_->TypeNotInDexCache();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800586 return false;
587 }
Ian Rogers996cc582012-02-14 22:23:29 -0800588 bool result = IsImageClass(ClassHelper(resolved_class).GetDescriptor());
589 if (result) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800590 stats_->TypeInDexCache();
Ian Rogers996cc582012-02-14 22:23:29 -0800591 } else {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800592 stats_->TypeNotInDexCache();
Ian Rogers996cc582012-02-14 22:23:29 -0800593 }
594 return result;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800595}
596
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700597bool Compiler::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file,
Ian Rogers996cc582012-02-14 22:23:29 -0800598 uint32_t string_idx) {
Ian Rogers1bddec32012-02-04 12:27:34 -0800599 // TODO: Add support for loading strings referenced by image_classes_
600 // See also Compiler::ResolveDexFile
601
602 // The following is a test saying that if we're building the image without a restricted set of
603 // 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 -0700604 bool result = IsImage() && image_classes_ == NULL;
605 if (result) {
606 ScopedObjectAccess soa(Thread::Current());
607 DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
608 result = dex_cache->GetResolvedString(string_idx) != NULL;
609 }
Ian Rogers996cc582012-02-14 22:23:29 -0800610 if (result) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800611 stats_->StringInDexCache();
Ian Rogers996cc582012-02-14 22:23:29 -0800612 } else {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800613 stats_->StringNotInDexCache();
Ian Rogers996cc582012-02-14 22:23:29 -0800614 }
615 return result;
Ian Rogers1bddec32012-02-04 12:27:34 -0800616}
617
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700618bool Compiler::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
619 uint32_t type_idx) {
620 ScopedObjectAccess soa(Thread::Current());
621 DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
Ian Rogers1bddec32012-02-04 12:27:34 -0800622 // Get type from dex cache assuming it was populated by the verifier
623 Class* resolved_class = dex_cache->GetResolvedType(type_idx);
624 if (resolved_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800625 stats_->TypeNeedsAccessCheck();
Ian Rogers1bddec32012-02-04 12:27:34 -0800626 return false; // Unknown class needs access checks.
627 }
628 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
629 Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
630 if (referrer_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800631 stats_->TypeNeedsAccessCheck();
Ian Rogers1bddec32012-02-04 12:27:34 -0800632 return false; // Incomplete referrer knowledge needs access check.
633 }
634 // Perform access check, will return true if access is ok or false if we're going to have to
635 // check this at runtime (for example for class loaders).
Ian Rogers996cc582012-02-14 22:23:29 -0800636 bool result = referrer_class->CanAccess(resolved_class);
637 if (result) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800638 stats_->TypeDoesntNeedAccessCheck();
Ian Rogers996cc582012-02-14 22:23:29 -0800639 } else {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800640 stats_->TypeNeedsAccessCheck();
Ian Rogers996cc582012-02-14 22:23:29 -0800641 }
642 return result;
Ian Rogers1bddec32012-02-04 12:27:34 -0800643}
644
645bool Compiler::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx,
Ian Rogers1bddec32012-02-04 12:27:34 -0800646 const DexFile& dex_file,
Ian Rogers996cc582012-02-14 22:23:29 -0800647 uint32_t type_idx) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700648 ScopedObjectAccess soa(Thread::Current());
649 DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
Ian Rogers1bddec32012-02-04 12:27:34 -0800650 // Get type from dex cache assuming it was populated by the verifier.
651 Class* resolved_class = dex_cache->GetResolvedType(type_idx);
652 if (resolved_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800653 stats_->TypeNeedsAccessCheck();
Ian Rogers1bddec32012-02-04 12:27:34 -0800654 return false; // Unknown class needs access checks.
655 }
656 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
657 Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
658 if (referrer_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800659 stats_->TypeNeedsAccessCheck();
Ian Rogers1bddec32012-02-04 12:27:34 -0800660 return false; // Incomplete referrer knowledge needs access check.
661 }
662 // Perform access and instantiable checks, will return true if access is ok or false if we're
663 // going to have to check this at runtime (for example for class loaders).
Ian Rogers996cc582012-02-14 22:23:29 -0800664 bool result = referrer_class->CanAccess(resolved_class) && resolved_class->IsInstantiable();
665 if (result) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800666 stats_->TypeDoesntNeedAccessCheck();
Ian Rogers996cc582012-02-14 22:23:29 -0800667 } else {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800668 stats_->TypeNeedsAccessCheck();
Ian Rogers996cc582012-02-14 22:23:29 -0800669 }
670 return result;
Ian Rogers1bddec32012-02-04 12:27:34 -0800671}
672
Ian Rogers08f753d2012-08-24 14:35:25 -0700673static Class* ComputeCompilingMethodsClass(ScopedObjectAccess& soa,
674 OatCompilationUnit* mUnit)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700675 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700676 DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
677 ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
678 const DexFile::MethodId& referrer_method_id = mUnit->dex_file_->GetMethodId(mUnit->method_idx_);
679 return mUnit->class_linker_->ResolveType(*mUnit->dex_file_, referrer_method_id.class_idx_,
680 dex_cache, class_loader);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800681}
682
Ian Rogers08f753d2012-08-24 14:35:25 -0700683static Field* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAccess& soa,
684 OatCompilationUnit* mUnit,
685 uint32_t field_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700686 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700687 DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
688 ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
689 return mUnit->class_linker_->ResolveField(*mUnit->dex_file_, field_idx, dex_cache,
690 class_loader, false);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800691}
692
Mathieu Chartier66f19252012-09-18 08:57:04 -0700693static AbstractMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
Ian Rogers08f753d2012-08-24 14:35:25 -0700694 OatCompilationUnit* mUnit,
695 uint32_t method_idx,
696 InvokeType type)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700697 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700698 DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
699 ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
700 return mUnit->class_linker_->ResolveMethod(*mUnit->dex_file_, method_idx, dex_cache,
jeffhaoc0228b82012-08-29 18:15:05 -0700701 class_loader, NULL, type);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800702}
703
Logan Chien4dd96f52012-02-29 01:26:58 +0800704bool Compiler::ComputeInstanceFieldInfo(uint32_t field_idx, OatCompilationUnit* mUnit,
jeffhao8cd6dda2012-02-22 10:15:34 -0800705 int& field_offset, bool& is_volatile, bool is_put) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700706 ScopedObjectAccess soa(Thread::Current());
Ian Rogers08f753d2012-08-24 14:35:25 -0700707 // Conservative defaults.
Ian Rogers1bddec32012-02-04 12:27:34 -0800708 field_offset = -1;
709 is_volatile = true;
Ian Rogers08f753d2012-08-24 14:35:25 -0700710 // Try to resolve field and ignore if an Incompatible Class Change Error (ie is static).
711 Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
712 if (resolved_field != NULL && !resolved_field->IsStatic()) {
713 Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
Ian Rogerse2645d32012-04-11 14:42:42 -0700714 if (referrer_class != NULL) {
715 Class* fields_class = resolved_field->GetDeclaringClass();
716 bool access_ok = referrer_class->CanAccess(fields_class) &&
717 referrer_class->CanAccessMember(fields_class,
718 resolved_field->GetAccessFlags());
719 if (!access_ok) {
720 // The referring class can't access the resolved field, this may occur as a result of a
721 // protected field being made public by a sub-class. Resort to the dex file to determine
722 // the correct class for the access check.
Ian Rogers4445a7e2012-10-05 17:19:13 -0700723 const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
Ian Rogerse2645d32012-04-11 14:42:42 -0700724 Class* dex_fields_class = mUnit->class_linker_->ResolveType(dex_file,
725 dex_file.GetFieldId(field_idx).class_idx_,
726 referrer_class);
727 access_ok = referrer_class->CanAccess(dex_fields_class) &&
728 referrer_class->CanAccessMember(dex_fields_class,
729 resolved_field->GetAccessFlags());
730 }
731 bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal() &&
732 fields_class != referrer_class;
733 if (access_ok && !is_write_to_final_from_wrong_class) {
734 field_offset = resolved_field->GetOffset().Int32Value();
735 is_volatile = resolved_field->IsVolatile();
736 stats_->ResolvedInstanceField();
737 return true; // Fast path.
738 }
Ian Rogers1bddec32012-02-04 12:27:34 -0800739 }
740 }
741 // Clean up any exception left by field/type resolution
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700742 if (soa.Self()->IsExceptionPending()) {
743 soa.Self()->ClearException();
Ian Rogers1bddec32012-02-04 12:27:34 -0800744 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800745 stats_->UnresolvedInstanceField();
Ian Rogers1bddec32012-02-04 12:27:34 -0800746 return false; // Incomplete knowledge needs slow path.
747}
748
Logan Chien4dd96f52012-02-29 01:26:58 +0800749bool Compiler::ComputeStaticFieldInfo(uint32_t field_idx, OatCompilationUnit* mUnit,
Ian Rogers1bddec32012-02-04 12:27:34 -0800750 int& field_offset, int& ssb_index,
jeffhao8cd6dda2012-02-22 10:15:34 -0800751 bool& is_referrers_class, bool& is_volatile, bool is_put) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700752 ScopedObjectAccess soa(Thread::Current());
Ian Rogers08f753d2012-08-24 14:35:25 -0700753 // Conservative defaults.
Ian Rogers1bddec32012-02-04 12:27:34 -0800754 field_offset = -1;
755 ssb_index = -1;
756 is_referrers_class = false;
757 is_volatile = true;
Ian Rogers08f753d2012-08-24 14:35:25 -0700758 // Try to resolve field and ignore if an Incompatible Class Change Error (ie isn't static).
759 Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
760 if (resolved_field != NULL && resolved_field->IsStatic()) {
761 Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
Ian Rogers1bddec32012-02-04 12:27:34 -0800762 if (referrer_class != NULL) {
jeffhao8cd6dda2012-02-22 10:15:34 -0800763 Class* fields_class = resolved_field->GetDeclaringClass();
764 if (fields_class == referrer_class) {
Ian Rogers1bddec32012-02-04 12:27:34 -0800765 is_referrers_class = true; // implies no worrying about class initialization
766 field_offset = resolved_field->GetOffset().Int32Value();
767 is_volatile = resolved_field->IsVolatile();
Ian Rogersc8b306f2012-02-17 21:34:44 -0800768 stats_->ResolvedLocalStaticField();
Ian Rogers1bddec32012-02-04 12:27:34 -0800769 return true; // fast path
770 } else {
Ian Rogerse2645d32012-04-11 14:42:42 -0700771 bool access_ok = referrer_class->CanAccess(fields_class) &&
772 referrer_class->CanAccessMember(fields_class,
773 resolved_field->GetAccessFlags());
774 if (!access_ok) {
775 // The referring class can't access the resolved field, this may occur as a result of a
776 // protected field being made public by a sub-class. Resort to the dex file to determine
777 // the correct class for the access check. Don't change the field's class as that is
778 // used to identify the SSB.
Ian Rogers4445a7e2012-10-05 17:19:13 -0700779 const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
Ian Rogerse2645d32012-04-11 14:42:42 -0700780 Class* dex_fields_class =
781 mUnit->class_linker_->ResolveType(dex_file,
782 dex_file.GetFieldId(field_idx).class_idx_,
783 referrer_class);
784 access_ok = referrer_class->CanAccess(dex_fields_class) &&
785 referrer_class->CanAccessMember(dex_fields_class,
786 resolved_field->GetAccessFlags());
787 }
jeffhao8cd6dda2012-02-22 10:15:34 -0800788 bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal();
Ian Rogerse2645d32012-04-11 14:42:42 -0700789 if (access_ok && !is_write_to_final_from_wrong_class) {
Ian Rogers1bddec32012-02-04 12:27:34 -0800790 // We have the resolved field, we must make it into a ssbIndex for the referrer
791 // in its static storage base (which may fail if it doesn't have a slot for it)
Ian Rogers4103ad22012-02-06 09:18:25 -0800792 // TODO: for images we can elide the static storage base null check
793 // if we know there's a non-null entry in the image
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700794 DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
795 if (fields_class->GetDexCache() == dex_cache) {
Ian Rogers4103ad22012-02-06 09:18:25 -0800796 // common case where the dex cache of both the referrer and the field are the same,
797 // no need to search the dex file
798 ssb_index = fields_class->GetDexTypeIndex();
799 field_offset = resolved_field->GetOffset().Int32Value();
800 is_volatile = resolved_field->IsVolatile();
Ian Rogersc8b306f2012-02-17 21:34:44 -0800801 stats_->ResolvedStaticField();
Ian Rogers4103ad22012-02-06 09:18:25 -0800802 return true;
803 }
Ian Rogerse2645d32012-04-11 14:42:42 -0700804 // Search dex file for localized ssb index, may fail if field's class is a parent
805 // of the class mentioned in the dex file and there is no dex cache entry.
Ian Rogers1bddec32012-02-04 12:27:34 -0800806 std::string descriptor(FieldHelper(resolved_field).GetDeclaringClassDescriptor());
807 const DexFile::StringId* string_id =
Logan Chien4dd96f52012-02-29 01:26:58 +0800808 mUnit->dex_file_->FindStringId(descriptor);
Ian Rogers1bddec32012-02-04 12:27:34 -0800809 if (string_id != NULL) {
810 const DexFile::TypeId* type_id =
Logan Chien4dd96f52012-02-29 01:26:58 +0800811 mUnit->dex_file_->FindTypeId(mUnit->dex_file_->GetIndexForStringId(*string_id));
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700812 if (type_id != NULL) {
Ian Rogers1bddec32012-02-04 12:27:34 -0800813 // medium path, needs check of static storage base being initialized
Logan Chien4dd96f52012-02-29 01:26:58 +0800814 ssb_index = mUnit->dex_file_->GetIndexForTypeId(*type_id);
Ian Rogers1bddec32012-02-04 12:27:34 -0800815 field_offset = resolved_field->GetOffset().Int32Value();
816 is_volatile = resolved_field->IsVolatile();
Ian Rogersc8b306f2012-02-17 21:34:44 -0800817 stats_->ResolvedStaticField();
Ian Rogers1bddec32012-02-04 12:27:34 -0800818 return true;
819 }
820 }
821 }
822 }
823 }
824 }
825 // Clean up any exception left by field/type resolution
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700826 if (soa.Self()->IsExceptionPending()) {
827 soa.Self()->ClearException();
Ian Rogers1bddec32012-02-04 12:27:34 -0800828 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800829 stats_->UnresolvedStaticField();
Ian Rogers1bddec32012-02-04 12:27:34 -0800830 return false; // Incomplete knowledge needs slow path.
831}
832
Mathieu Chartier66f19252012-09-18 08:57:04 -0700833void Compiler::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, AbstractMethod* method,
Ian Rogers2ed3b952012-03-17 11:49:39 -0700834 uintptr_t& direct_code, uintptr_t& direct_method) {
Ian Rogers137e88f2012-10-08 17:46:47 -0700835 // For direct and static methods compute possible direct_code and direct_method values, ie
836 // an address for the Method* being invoked and an address of the code for that Method*.
837 // For interface calls compute a value for direct_method that is the interface method being
838 // invoked, so this can be passed to the out-of-line runtime support code.
Ian Rogers2ed3b952012-03-17 11:49:39 -0700839 direct_code = 0;
840 direct_method = 0;
Ian Rogers137e88f2012-10-08 17:46:47 -0700841 if (sharp_type != kStatic && sharp_type != kDirect && sharp_type != kInterface) {
Ian Rogers2ed3b952012-03-17 11:49:39 -0700842 return;
843 }
Ian Rogers2ed3b952012-03-17 11:49:39 -0700844 bool method_code_in_boot = method->GetDeclaringClass()->GetClassLoader() == NULL;
845 if (!method_code_in_boot) {
846 return;
847 }
848 bool has_clinit_trampoline = method->IsStatic() && !method->GetDeclaringClass()->IsInitialized();
849 if (has_clinit_trampoline) {
850 return;
851 }
Ian Rogersc468e922012-10-10 18:11:33 -0700852 if (sharp_type != kInterface) { // Interfaces always go via a trampoline.
853 stats_->DirectCallsToBoot(type);
854 }
Ian Rogers2ed3b952012-03-17 11:49:39 -0700855 stats_->DirectMethodsToBoot(type);
Ian Rogers3fa13792012-03-18 15:53:45 -0700856 bool compiling_boot = Runtime::Current()->GetHeap()->GetSpaces().size() == 1;
857 if (compiling_boot) {
Brian Carlstrom0637e272012-03-20 01:07:52 -0700858 const bool kSupportBootImageFixup = true;
Ian Rogers3fa13792012-03-18 15:53:45 -0700859 if (kSupportBootImageFixup) {
860 MethodHelper mh(method);
861 if (IsImageClass(mh.GetDeclaringClassDescriptor())) {
Brian Carlstrom0637e272012-03-20 01:07:52 -0700862 // We can only branch directly to Methods that are resolved in the DexCache.
863 // Otherwise we won't invoke the resolution trampoline.
Ian Rogers3fa13792012-03-18 15:53:45 -0700864 direct_method = -1;
Brian Carlstrom0637e272012-03-20 01:07:52 -0700865 direct_code = -1;
Ian Rogers3fa13792012-03-18 15:53:45 -0700866 }
Ian Rogers3fa13792012-03-18 15:53:45 -0700867 }
868 } else {
Mathieu Chartierb062fdd2012-07-03 09:51:48 -0700869 if (Runtime::Current()->GetHeap()->FindSpaceFromObject(method)->IsImageSpace()) {
Ian Rogers3fa13792012-03-18 15:53:45 -0700870 direct_method = reinterpret_cast<uintptr_t>(method);
871 }
872 direct_code = reinterpret_cast<uintptr_t>(method->GetCode());
Ian Rogers2ed3b952012-03-17 11:49:39 -0700873 }
Ian Rogers2ed3b952012-03-17 11:49:39 -0700874}
875
Ian Rogersfb6adba2012-03-04 21:51:51 -0800876bool Compiler::ComputeInvokeInfo(uint32_t method_idx, OatCompilationUnit* mUnit, InvokeType& type,
Ian Rogers2ed3b952012-03-17 11:49:39 -0700877 int& vtable_idx, uintptr_t& direct_code,
878 uintptr_t& direct_method) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700879 ScopedObjectAccess soa(Thread::Current());
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800880 vtable_idx = -1;
Ian Rogers2ed3b952012-03-17 11:49:39 -0700881 direct_code = 0;
882 direct_method = 0;
Mathieu Chartier66f19252012-09-18 08:57:04 -0700883 AbstractMethod* resolved_method =
Ian Rogers08f753d2012-08-24 14:35:25 -0700884 ComputeMethodReferencedFromCompilingMethod(soa, mUnit, method_idx, type);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800885 if (resolved_method != NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -0700886 // Don't try to fast-path if we don't understand the caller's class or this appears to be an
887 // Incompatible Class Change Error.
888 Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
889 bool icce = resolved_method->CheckIncompatibleClassChange(type);
890 if (referrer_class != NULL && !icce) {
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800891 Class* methods_class = resolved_method->GetDeclaringClass();
892 if (!referrer_class->CanAccess(methods_class) ||
893 !referrer_class->CanAccessMember(methods_class,
Ian Rogers996cc582012-02-14 22:23:29 -0800894 resolved_method->GetAccessFlags())) {
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800895 // The referring class can't access the resolved method, this may occur as a result of a
896 // protected method being made public by implementing an interface that re-declares the
Ian Rogers08f753d2012-08-24 14:35:25 -0700897 // method public. Resort to the dex file to determine the correct class for the access
898 // check.
Ian Rogers4445a7e2012-10-05 17:19:13 -0700899 const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800900 methods_class =
Logan Chien4dd96f52012-02-29 01:26:58 +0800901 mUnit->class_linker_->ResolveType(dex_file,
902 dex_file.GetMethodId(method_idx).class_idx_,
903 referrer_class);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800904 }
905 if (referrer_class->CanAccess(methods_class) &&
Ian Rogers137e88f2012-10-08 17:46:47 -0700906 referrer_class->CanAccessMember(methods_class, resolved_method->GetAccessFlags())) {
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800907 vtable_idx = resolved_method->GetMethodIndex();
Ian Rogersf320b632012-03-13 18:47:47 -0700908 const bool kEnableSharpening = true;
Ian Rogers2ed3b952012-03-17 11:49:39 -0700909 // Sharpen a virtual call into a direct call when the target is known.
910 bool can_sharpen = type == kVirtual && (resolved_method->IsFinal() ||
Ian Rogers08f753d2012-08-24 14:35:25 -0700911 methods_class->IsFinal());
912 // Ensure the vtable index will be correct to dispatch in the vtable of the super class.
jeffhao4155fcd2012-03-21 11:42:12 -0700913 can_sharpen = can_sharpen || (type == kSuper && referrer_class != methods_class &&
Ian Rogers08f753d2012-08-24 14:35:25 -0700914 referrer_class->IsSubClass(methods_class) &&
915 vtable_idx < methods_class->GetVTable()->GetLength() &&
916 methods_class->GetVTable()->Get(vtable_idx) == resolved_method);
Ian Rogers2ed3b952012-03-17 11:49:39 -0700917 if (kEnableSharpening && can_sharpen) {
918 stats_->ResolvedMethod(type);
Ian Rogersfb6adba2012-03-04 21:51:51 -0800919 // Sharpen a virtual call into a direct call. The method_idx is into referrer's
920 // dex cache, check that this resolved method is where we expect it.
921 CHECK(referrer_class->GetDexCache()->GetResolvedMethod(method_idx) == resolved_method)
Ian Rogers08f753d2012-08-24 14:35:25 -0700922 << PrettyMethod(resolved_method);
Ian Rogers2ed3b952012-03-17 11:49:39 -0700923 stats_->VirtualMadeDirect(type);
924 GetCodeAndMethodForDirectCall(type, kDirect, resolved_method, direct_code, direct_method);
925 type = kDirect;
926 return true;
927 } else if (type == kSuper) {
Ian Rogers08f753d2012-08-24 14:35:25 -0700928 // Unsharpened super calls are suspicious so go slow-path.
Ian Rogers2ed3b952012-03-17 11:49:39 -0700929 } else {
930 stats_->ResolvedMethod(type);
931 GetCodeAndMethodForDirectCall(type, type, resolved_method, direct_code, direct_method);
932 return true;
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800933 }
934 }
935 }
936 }
937 // Clean up any exception left by method/type resolution
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700938 if (soa.Self()->IsExceptionPending()) {
939 soa.Self()->ClearException();
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800940 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800941 stats_->UnresolvedMethod(type);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800942 return false; // Incomplete knowledge needs slow path.
943}
944
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700945void Compiler::AddCodePatch(const DexFile* dex_file,
Brian Carlstromf5822582012-03-19 22:34:31 -0700946 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700947 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700948 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700949 InvokeType target_invoke_type,
Ian Rogers3fa13792012-03-18 15:53:45 -0700950 size_t literal_offset) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700951 MutexLock mu(Thread::Current(), compiled_methods_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700952 code_to_patch_.push_back(new PatchInformation(dex_file,
Brian Carlstromf5822582012-03-19 22:34:31 -0700953 referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700954 referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700955 target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700956 target_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700957 literal_offset));
Ian Rogers3fa13792012-03-18 15:53:45 -0700958}
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700959void Compiler::AddMethodPatch(const DexFile* dex_file,
Brian Carlstromf5822582012-03-19 22:34:31 -0700960 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700961 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700962 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700963 InvokeType target_invoke_type,
Ian Rogers3fa13792012-03-18 15:53:45 -0700964 size_t literal_offset) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700965 MutexLock mu(Thread::Current(), compiled_methods_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700966 methods_to_patch_.push_back(new PatchInformation(dex_file,
Brian Carlstromf5822582012-03-19 22:34:31 -0700967 referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700968 referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700969 target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700970 target_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700971 literal_offset));
Ian Rogers3fa13792012-03-18 15:53:45 -0700972}
973
Ian Rogers0399dde2012-06-06 17:09:28 -0700974class CompilationContext {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800975 public:
Ian Rogers0399dde2012-06-06 17:09:28 -0700976 CompilationContext(ClassLinker* class_linker,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700977 jobject class_loader,
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800978 Compiler* compiler,
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800979 const DexFile* dex_file)
980 : class_linker_(class_linker),
981 class_loader_(class_loader),
982 compiler_(compiler),
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800983 dex_file_(dex_file) {}
984
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700985 ClassLinker* GetClassLinker() const {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800986 CHECK(class_linker_ != NULL);
987 return class_linker_;
988 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700989
990 jobject GetClassLoader() const {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800991 return class_loader_;
992 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700993
994 Compiler* GetCompiler() const {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800995 CHECK(compiler_ != NULL);
996 return compiler_;
997 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700998
999 const DexFile* GetDexFile() const {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001000 CHECK(dex_file_ != NULL);
1001 return dex_file_;
1002 }
1003
1004 private:
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001005 ClassLinker* const class_linker_;
1006 const jobject class_loader_;
1007 Compiler* const compiler_;
1008 const DexFile* const dex_file_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001009};
1010
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001011typedef void Callback(const CompilationContext* context, size_t index);
1012
1013static void ForAll(CompilationContext* context, size_t begin, size_t end, Callback callback,
1014 size_t thread_count);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001015
1016class WorkerThread {
1017 public:
Ian Rogers0399dde2012-06-06 17:09:28 -07001018 WorkerThread(CompilationContext* context, size_t begin, size_t end, Callback callback, size_t stripe, bool spawn)
Elliott Hughes1e409252012-02-06 11:21:27 -08001019 : spawn_(spawn), context_(context), begin_(begin), end_(end), callback_(callback), stripe_(stripe) {
1020 if (spawn_) {
Elliott Hughesbf1b4572012-05-24 19:11:39 -07001021 // Mac OS stacks are only 512KiB. Make sure we have the same stack size on all platforms.
1022 pthread_attr_t attr;
1023 CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new compiler worker thread");
1024 CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, 1*MB), "new compiler worker thread");
1025 CHECK_PTHREAD_CALL(pthread_create, (&pthread_, &attr, &Go, this), "new compiler worker thread");
1026 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new compiler worker thread");
Elliott Hughes1e409252012-02-06 11:21:27 -08001027 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001028 }
1029
1030 ~WorkerThread() {
Elliott Hughes1e409252012-02-06 11:21:27 -08001031 if (spawn_) {
1032 CHECK_PTHREAD_CALL(pthread_join, (pthread_, NULL), "compiler worker shutdown");
1033 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001034 }
1035
1036 private:
Ian Rogersb726dcb2012-09-05 08:57:23 -07001037 static void* Go(void* arg) LOCKS_EXCLUDED(Locks::mutator_lock_) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001038 WorkerThread* worker = reinterpret_cast<WorkerThread*>(arg);
1039 Runtime* runtime = Runtime::Current();
Elliott Hughes1e409252012-02-06 11:21:27 -08001040 if (worker->spawn_) {
Ian Rogers120f1c72012-09-28 17:17:10 -07001041 CHECK(runtime->AttachCurrentThread("Compiler Worker", true, NULL));
Elliott Hughes1e409252012-02-06 11:21:27 -08001042 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001043 worker->Run();
Elliott Hughes1e409252012-02-06 11:21:27 -08001044 if (worker->spawn_) {
Elliott Hughes1e409252012-02-06 11:21:27 -08001045 runtime->DetachCurrentThread();
1046 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001047 return NULL;
1048 }
1049
Ian Rogersb726dcb2012-09-05 08:57:23 -07001050 void Go() LOCKS_EXCLUDED(Locks::mutator_lock_) {
Elliott Hughes1e409252012-02-06 11:21:27 -08001051 Go(this);
1052 }
1053
Ian Rogersb726dcb2012-09-05 08:57:23 -07001054 void Run() LOCKS_EXCLUDED(Locks::mutator_lock_) {
Brian Carlstrom64277f32012-03-26 23:53:34 -07001055 Thread* self = Thread::Current();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001056 for (size_t i = begin_; i < end_; i += stripe_) {
1057 callback_(context_, i);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001058 self->AssertNoPendingException();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001059 }
1060 }
1061
1062 pthread_t pthread_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001063 // Was this thread spawned or is it the main thread?
1064 const bool spawn_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001065
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001066 const CompilationContext* const context_;
1067 const size_t begin_;
1068 const size_t end_;
Ian Rogers1b09b092012-08-20 15:35:52 -07001069 Callback* callback_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001070 const size_t stripe_;
Elliott Hughes1e409252012-02-06 11:21:27 -08001071
Ian Rogers0399dde2012-06-06 17:09:28 -07001072 friend void ForAll(CompilationContext*, size_t, size_t, Callback, size_t);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001073};
1074
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001075static void ForAll(CompilationContext* context, size_t begin, size_t end, Callback callback,
1076 size_t thread_count)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001077 LOCKS_EXCLUDED(Locks::mutator_lock_) {
Brian Carlstrom64277f32012-03-26 23:53:34 -07001078 Thread* self = Thread::Current();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001079 self->AssertNoPendingException();
Elliott Hughes1e409252012-02-06 11:21:27 -08001080 CHECK_GT(thread_count, 0U);
Elliott Hughes81d91512012-02-03 16:38:43 -08001081
Elliott Hughes1e409252012-02-06 11:21:27 -08001082 std::vector<WorkerThread*> threads;
Elliott Hughes81d91512012-02-03 16:38:43 -08001083 for (size_t i = 0; i < thread_count; ++i) {
Elliott Hughes1e409252012-02-06 11:21:27 -08001084 threads.push_back(new WorkerThread(context, begin + i, end, callback, thread_count, (i != 0)));
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001085 }
Elliott Hughes1e409252012-02-06 11:21:27 -08001086 threads[0]->Go();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001087
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001088 // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1089 // thread destructor's called below perform join).
Ian Rogers50b35e22012-10-04 10:09:15 -07001090 CHECK_NE(self->GetState(), kRunnable);
Elliott Hughes81d91512012-02-03 16:38:43 -08001091 STLDeleteElements(&threads);
1092}
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001093
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001094// Return true if the class should be skipped during compilation. We
1095// never skip classes in the boot class loader. However, if we have a
1096// non-boot class loader and we can resolve the class in the boot
1097// class loader, we do skip the class. This happens if an app bundles
1098// classes found in the boot classpath. Since at runtime we will
1099// select the class from the boot classpath, do not attempt to resolve
1100// or compile it now.
1101static bool SkipClass(ClassLoader* class_loader,
1102 const DexFile& dex_file,
1103 const DexFile::ClassDef& class_def)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001104 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001105 if (class_loader == NULL) {
1106 return false;
1107 }
1108 const char* descriptor = dex_file.GetClassDescriptor(class_def);
1109 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1110 Class* klass = class_linker->FindClass(descriptor, NULL);
1111 if (klass == NULL) {
1112 Thread* self = Thread::Current();
1113 CHECK(self->IsExceptionPending());
1114 self->ClearException();
1115 return false;
1116 }
1117 return true;
1118}
1119
1120static void ResolveClassFieldsAndMethods(const CompilationContext* context, size_t class_def_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001121 LOCKS_EXCLUDED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001122 ScopedObjectAccess soa(Thread::Current());
1123 ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001124 const DexFile& dex_file = *context->GetDexFile();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001125
1126 // Method and Field are the worst. We can't resolve without either
1127 // context from the code use (to disambiguate virtual vs direct
1128 // method and instance vs static field) or from class
1129 // definitions. While the compiler will resolve what it can as it
1130 // needs it, here we try to resolve fields and methods used in class
1131 // definitions, since many of them many never be referenced by
1132 // generated code.
1133 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001134 if (SkipClass(class_loader, dex_file, class_def)) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001135 return;
1136 }
1137
1138 // Note the class_data pointer advances through the headers,
1139 // static fields, instance fields, direct methods, and virtual
1140 // methods.
1141 const byte* class_data = dex_file.GetClassData(class_def);
1142 if (class_data == NULL) {
1143 // empty class such as a marker interface
1144 return;
1145 }
Brian Carlstrom5ead0952011-11-28 22:55:52 -08001146 Thread* self = Thread::Current();
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001147 ClassLinker* class_linker = context->GetClassLinker();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001148 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
1149 ClassDataItemIterator it(dex_file, class_data);
1150 while (it.HasNextStaticField()) {
1151 Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001152 class_loader, true);
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.HasNextInstanceField()) {
1160 Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001161 class_loader, false);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001162 if (field == NULL) {
1163 CHECK(self->IsExceptionPending());
1164 self->ClearException();
1165 }
1166 it.Next();
1167 }
1168 while (it.HasNextDirectMethod()) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001169 AbstractMethod* 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 while (it.HasNextVirtualMethod()) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001178 AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
jeffhaoc0228b82012-08-29 18:15:05 -07001179 class_loader, NULL, it.GetMethodInvokeType(class_def));
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001180 if (method == NULL) {
1181 CHECK(self->IsExceptionPending());
1182 self->ClearException();
1183 }
1184 it.Next();
1185 }
1186 DCHECK(!it.HasNext());
1187}
1188
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001189static void ResolveType(const CompilationContext* context, size_t type_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001190 LOCKS_EXCLUDED(Locks::mutator_lock_) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001191 // Class derived values are more complicated, they require the linker and loader.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001192 ScopedObjectAccess soa(Thread::Current());
1193 ClassLinker* class_linker = context->GetClassLinker();
1194 const DexFile& dex_file = *context->GetDexFile();
1195 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
1196 ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
1197 Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
1198
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001199 if (klass == NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001200 CHECK(soa.Self()->IsExceptionPending());
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001201 Thread::Current()->ClearException();
1202 }
1203}
1204
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001205void Compiler::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
1206 TimingLogger& timings) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001207 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1208
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001209 // TODO: we could resolve strings here, although the string table is largely filled with class
1210 // and method names.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001211
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001212 CompilationContext context(class_linker, class_loader, this, &dex_file);
1213 ForAll(&context, 0, dex_file.NumTypeIds(), ResolveType, thread_count_);
Elliott Hughesff738062012-02-03 15:00:42 -08001214 timings.AddSplit("Resolve " + dex_file.GetLocation() + " Types");
Brian Carlstrom845490b2011-09-19 15:56:53 -07001215
Elliott Hughes5523ee02012-02-03 18:18:34 -08001216 ForAll(&context, 0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
Elliott Hughesff738062012-02-03 15:00:42 -08001217 timings.AddSplit("Resolve " + dex_file.GetLocation() + " MethodsAndFields");
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001218}
1219
Ian Rogers3d1548d2012-09-24 14:08:03 -07001220void Compiler::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1221 TimingLogger& timings) {
Brian Carlstromae826982011-11-09 01:33:42 -08001222 for (size_t i = 0; i != dex_files.size(); ++i) {
1223 const DexFile* dex_file = dex_files[i];
jeffhao98eacac2011-09-14 16:11:53 -07001224 CHECK(dex_file != NULL);
Ian Rogers3d1548d2012-09-24 14:08:03 -07001225 VerifyDexFile(class_loader, *dex_file, timings);
jeffhao98eacac2011-09-14 16:11:53 -07001226 }
1227}
1228
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001229static void VerifyClass(const CompilationContext* context, size_t class_def_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001230 LOCKS_EXCLUDED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001231 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001232 const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
1233 const char* descriptor = context->GetDexFile()->GetClassDescriptor(class_def);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001234 Class* klass =
1235 context->GetClassLinker()->FindClass(descriptor,
1236 soa.Decode<ClassLoader*>(context->GetClassLoader()));
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001237 if (klass == NULL) {
1238 Thread* self = Thread::Current();
1239 CHECK(self->IsExceptionPending());
1240 self->ClearException();
jeffhaof56197c2012-03-05 18:01:54 -08001241
1242 /*
1243 * At compile time, we can still structurally verify the class even if FindClass fails.
1244 * This is to ensure the class is structurally sound for compilation. An unsound class
1245 * will be rejected by the verifier and later skipped during compilation in the compiler.
1246 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001247 DexCache* dex_cache = context->GetClassLinker()->FindDexCache(*context->GetDexFile());
jeffhaof56197c2012-03-05 18:01:54 -08001248 std::string error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001249 if (verifier::MethodVerifier::VerifyClass(context->GetDexFile(),
1250 dex_cache,
1251 soa.Decode<ClassLoader*>(context->GetClassLoader()),
1252 class_def_index, error_msg) ==
1253 verifier::MethodVerifier::kHardFailure) {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001254 const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
jeffhaof56197c2012-03-05 18:01:54 -08001255 LOG(ERROR) << "Verification failed on class "
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001256 << PrettyDescriptor(context->GetDexFile()->GetClassDescriptor(class_def))
jeffhaof56197c2012-03-05 18:01:54 -08001257 << " because: " << error_msg;
1258 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001259 return;
1260 }
1261 CHECK(klass->IsResolved()) << PrettyClass(klass);
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001262 context->GetClassLinker()->VerifyClass(klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001263
1264 if (klass->IsErroneous()) {
1265 // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
1266 CHECK(Thread::Current()->IsExceptionPending());
1267 Thread::Current()->ClearException();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001268 }
1269
Ian Rogers9ffb0392012-09-10 11:56:50 -07001270 CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
1271 << PrettyDescriptor(klass) << ": state=" << klass->GetStatus();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001272 CHECK(!Thread::Current()->IsExceptionPending()) << PrettyTypeOf(Thread::Current()->GetException());
1273}
1274
Ian Rogers3d1548d2012-09-24 14:08:03 -07001275void Compiler::VerifyDexFile(jobject class_loader, const DexFile& dex_file, TimingLogger& timings) {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001276 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001277 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_);
Ian Rogers3d1548d2012-09-24 14:08:03 -07001279 timings.AddSplit("Verify " + dex_file.GetLocation());
1280}
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07001281
Ian Rogers3d1548d2012-09-24 14:08:03 -07001282static void InitializeClassWithoutClinit(const CompilationContext* context,
1283 size_t class_def_index)
1284 LOCKS_EXCLUDED(Locks::mutator_lock_) {
1285 const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
1286 ScopedObjectAccess soa(Thread::Current());
1287 ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
1288 const char* descriptor = context->GetDexFile()->GetClassDescriptor(class_def);
1289 Class* klass = context->GetClassLinker()->FindClass(descriptor, class_loader);
Ian Rogers1f539342012-10-03 21:09:42 -07001290 Thread* self = Thread::Current();
Ian Rogers3d1548d2012-09-24 14:08:03 -07001291 if (klass != NULL) {
Ian Rogers1f539342012-10-03 21:09:42 -07001292 ObjectLock lock(self, klass);
Ian Rogers3d1548d2012-09-24 14:08:03 -07001293 if (klass->IsVerified()) {
1294 // Only try to initialize classes that were successfully verified.
1295 bool compiling_boot = Runtime::Current()->GetHeap()->GetSpaces().size() == 1;
1296 bool can_init_static_fields = compiling_boot &&
1297 context->GetCompiler()->IsImageClass(descriptor);
1298 context->GetClassLinker()->EnsureInitialized(klass, false, can_init_static_fields);
1299 // If successfully initialized place in SSB array.
1300 if (klass->IsInitialized()) {
1301 klass->GetDexCache()->GetInitializedStaticStorage()->Set(klass->GetDexTypeIndex(), klass);
1302 }
1303 }
1304 // Record the final class status if necessary.
1305 Class::Status status = klass->GetStatus();
1306 Compiler::ClassReference ref(context->GetDexFile(), class_def_index);
1307 CompiledClass* compiled_class = context->GetCompiler()->GetCompiledClass(ref);
1308 if (compiled_class == NULL) {
1309 compiled_class = new CompiledClass(status);
1310 context->GetCompiler()->RecordClassStatus(ref, compiled_class);
1311 } else {
1312 DCHECK_EQ(status, compiled_class->GetStatus());
1313 }
1314 }
Ian Rogers1f539342012-10-03 21:09:42 -07001315 // Clear any class not found or verification exceptions.
1316 self->ClearException();
Ian Rogers3d1548d2012-09-24 14:08:03 -07001317}
1318
1319void Compiler::InitializeClassesWithoutClinit(jobject jni_class_loader, const DexFile& dex_file,
1320 TimingLogger& timings) {
1321 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1322 CompilationContext context(class_linker, jni_class_loader, this, &dex_file);
1323 ForAll(&context, 0, dex_file.NumClassDefs(), InitializeClassWithoutClinit, thread_count_);
1324 timings.AddSplit("InitializeNoClinit " + dex_file.GetLocation());
Brian Carlstroma5a97a22011-09-15 14:08:49 -07001325}
1326
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001327void Compiler::InitializeClassesWithoutClinit(jobject class_loader,
Ian Rogers3d1548d2012-09-24 14:08:03 -07001328 const std::vector<const DexFile*>& dex_files,
1329 TimingLogger& timings) {
Brian Carlstromae826982011-11-09 01:33:42 -08001330 for (size_t i = 0; i != dex_files.size(); ++i) {
1331 const DexFile* dex_file = dex_files[i];
Brian Carlstroma5a97a22011-09-15 14:08:49 -07001332 CHECK(dex_file != NULL);
Ian Rogers3d1548d2012-09-24 14:08:03 -07001333 InitializeClassesWithoutClinit(class_loader, *dex_file, timings);
Brian Carlstroma5a97a22011-09-15 14:08:49 -07001334 }
1335}
1336
Ian Rogers3d1548d2012-09-24 14:08:03 -07001337void Compiler::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
1338 TimingLogger& timings) {
Brian Carlstromae826982011-11-09 01:33:42 -08001339 for (size_t i = 0; i != dex_files.size(); ++i) {
1340 const DexFile* dex_file = dex_files[i];
Brian Carlstrom83db7722011-08-26 17:32:56 -07001341 CHECK(dex_file != NULL);
Ian Rogers3d1548d2012-09-24 14:08:03 -07001342 CompileDexFile(class_loader, *dex_file, timings);
Brian Carlstrom83db7722011-08-26 17:32:56 -07001343 }
1344}
1345
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001346void Compiler::CompileClass(const CompilationContext* context, size_t class_def_index) {
1347 jobject class_loader = context->GetClassLoader();
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001348 const DexFile& dex_file = *context->GetDexFile();
Elliott Hughesc225caa2012-02-03 15:43:37 -08001349 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001350 {
1351 ScopedObjectAccess soa(Thread::Current());
1352 ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
1353 if (SkipClass(class_loader, dex_file, class_def)) {
1354 return;
1355 }
Brian Carlstrom5ead0952011-11-28 22:55:52 -08001356 }
jeffhaod1224c72012-02-29 13:43:08 -08001357 ClassReference ref(&dex_file, class_def_index);
1358 // Skip compiling classes with generic verifier failures since they will still fail at runtime
Ian Rogers776ac1f2012-04-13 23:36:36 -07001359 if (verifier::MethodVerifier::IsClassRejected(ref)) {
jeffhaod1224c72012-02-29 13:43:08 -08001360 return;
1361 }
Ian Rogers0571d352011-11-03 19:51:38 -07001362 const byte* class_data = dex_file.GetClassData(class_def);
1363 if (class_data == NULL) {
1364 // empty class, probably a marker interface
1365 return;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001366 }
Ian Rogers0571d352011-11-03 19:51:38 -07001367 ClassDataItemIterator it(dex_file, class_data);
1368 // Skip fields
1369 while (it.HasNextStaticField()) {
1370 it.Next();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001371 }
Ian Rogers0571d352011-11-03 19:51:38 -07001372 while (it.HasNextInstanceField()) {
1373 it.Next();
1374 }
1375 // Compile direct methods
Brian Carlstrom68adbe42012-05-11 17:18:08 -07001376 int64_t previous_direct_method_idx = -1;
Ian Rogers0571d352011-11-03 19:51:38 -07001377 while (it.HasNextDirectMethod()) {
Brian Carlstrom6f29d0e2012-05-11 15:50:29 -07001378 uint32_t method_idx = it.GetMemberIndex();
1379 if (method_idx == previous_direct_method_idx) {
1380 // smali can create dex files with two encoded_methods sharing the same method_idx
1381 // http://code.google.com/p/smali/issues/detail?id=119
1382 it.Next();
1383 continue;
1384 }
1385 previous_direct_method_idx = method_idx;
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001386 context->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
Ian Rogers08f753d2012-08-24 14:35:25 -07001387 it.GetMethodInvokeType(class_def), method_idx,
1388 class_loader, dex_file);
Ian Rogers0571d352011-11-03 19:51:38 -07001389 it.Next();
1390 }
1391 // Compile virtual methods
Brian Carlstrom68adbe42012-05-11 17:18:08 -07001392 int64_t previous_virtual_method_idx = -1;
Ian Rogers0571d352011-11-03 19:51:38 -07001393 while (it.HasNextVirtualMethod()) {
Brian Carlstrom6f29d0e2012-05-11 15:50:29 -07001394 uint32_t method_idx = it.GetMemberIndex();
1395 if (method_idx == previous_virtual_method_idx) {
1396 // smali can create dex files with two encoded_methods sharing the same method_idx
1397 // http://code.google.com/p/smali/issues/detail?id=119
1398 it.Next();
1399 continue;
1400 }
1401 previous_virtual_method_idx = method_idx;
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001402 context->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
Ian Rogers08f753d2012-08-24 14:35:25 -07001403 it.GetMethodInvokeType(class_def), method_idx,
1404 class_loader, dex_file);
Ian Rogers0571d352011-11-03 19:51:38 -07001405 it.Next();
1406 }
1407 DCHECK(!it.HasNext());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001408}
1409
Ian Rogers3d1548d2012-09-24 14:08:03 -07001410void Compiler::CompileDexFile(jobject class_loader, const DexFile& dex_file,
1411 TimingLogger& timings) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001412 CompilationContext context(NULL, class_loader, this, &dex_file);
Elliott Hughes5523ee02012-02-03 18:18:34 -08001413 ForAll(&context, 0, dex_file.NumClassDefs(), Compiler::CompileClass, thread_count_);
Ian Rogers3d1548d2012-09-24 14:08:03 -07001414 timings.AddSplit("Compile " + dex_file.GetLocation());
Elliott Hughesc225caa2012-02-03 15:43:37 -08001415}
1416
Elliott Hughesa0e18062012-04-13 15:59:59 -07001417static std::string MakeInvokeStubKey(bool is_static, const char* shorty) {
1418 std::string key(shorty);
1419 if (is_static) {
1420 key += "$"; // Must not be a shorty type character.
1421 }
1422 return key;
1423}
1424
Ian Rogersa3760aa2011-11-14 14:32:37 -08001425void Compiler::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
Ian Rogers08f753d2012-08-24 14:35:25 -07001426 InvokeType invoke_type, uint32_t method_idx, jobject class_loader,
Ian Rogersa3760aa2011-11-14 14:32:37 -08001427 const DexFile& dex_file) {
Elliott Hughesf09afe82011-10-16 14:24:21 -07001428 CompiledMethod* compiled_method = NULL;
Elliott Hughesbb551fa2012-01-25 16:35:29 -08001429 uint64_t start_ns = NanoTime();
Logan Chien4dd96f52012-02-29 01:26:58 +08001430
Ian Rogers169c9a72011-11-13 20:13:17 -08001431 if ((access_flags & kAccNative) != 0) {
Ian Rogers57b86d42012-03-27 16:05:41 -07001432 compiled_method = (*jni_compiler_)(*this, access_flags, method_idx, dex_file);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001433 CHECK(compiled_method != NULL);
Ian Rogers169c9a72011-11-13 20:13:17 -08001434 } else if ((access_flags & kAccAbstract) != 0) {
Brian Carlstrom2cc022b2011-08-25 10:05:39 -07001435 } else {
Ian Rogers08f753d2012-08-24 14:35:25 -07001436 compiled_method = (*compiler_)(*this, code_item, access_flags, invoke_type, method_idx,
1437 class_loader, dex_file);
Elliott Hughesbb551fa2012-01-25 16:35:29 -08001438 CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
1439 }
Ian Rogers3bb17a62012-01-27 23:56:44 -08001440 uint64_t duration_ns = NanoTime() - start_ns;
buzbee5abfa3e2012-01-31 17:01:43 -08001441 if (duration_ns > MsToNs(100)) {
Elliott Hughesbb551fa2012-01-25 16:35:29 -08001442 LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
Ian Rogers3bb17a62012-01-27 23:56:44 -08001443 << " took " << PrettyDuration(duration_ns);
Elliott Hughesf09afe82011-10-16 14:24:21 -07001444 }
1445
Ian Rogers50b35e22012-10-04 10:09:15 -07001446 Thread* self = Thread::Current();
Elliott Hughesf09afe82011-10-16 14:24:21 -07001447 if (compiled_method != NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07001448 MethodReference ref(&dex_file, method_idx);
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001449 CHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001450 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001451 MutexLock mu(self, compiled_methods_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001452 compiled_methods_.Put(ref, compiled_method);
1453 }
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001454 DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
Brian Carlstrom2cc022b2011-08-25 10:05:39 -07001455 }
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -07001456
Ian Rogers45619fc2012-02-29 11:15:25 -08001457 uint32_t shorty_len;
1458 const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx), &shorty_len);
Ian Rogers169c9a72011-11-13 20:13:17 -08001459 bool is_static = (access_flags & kAccStatic) != 0;
Elliott Hughesa0e18062012-04-13 15:59:59 -07001460 std::string key(MakeInvokeStubKey(is_static, shorty));
1461 const CompiledInvokeStub* compiled_invoke_stub = FindInvokeStub(key);
Ian Rogers0571d352011-11-03 19:51:38 -07001462 if (compiled_invoke_stub == NULL) {
Shih-wei Liaoc4c98812012-03-10 21:55:51 -08001463 compiled_invoke_stub = (*create_invoke_stub_)(*this, is_static, shorty, shorty_len);
Ian Rogers0571d352011-11-03 19:51:38 -07001464 CHECK(compiled_invoke_stub != NULL);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001465 InsertInvokeStub(key, compiled_invoke_stub);
Ian Rogers2c8f6532011-09-02 17:16:34 -07001466 }
Logan Chien7a2a23a2012-06-06 11:01:00 +08001467
1468#if defined(ART_USE_LLVM_COMPILER)
1469 if (!is_static) {
1470 const CompiledInvokeStub* compiled_proxy_stub = FindProxyStub(shorty);
1471 if (compiled_proxy_stub == NULL) {
1472 compiled_proxy_stub = (*create_proxy_stub_)(*this, shorty, shorty_len);
1473 CHECK(compiled_proxy_stub != NULL);
1474 InsertProxyStub(shorty, compiled_proxy_stub);
1475 }
1476 }
1477#endif
1478
Ian Rogers50b35e22012-10-04 10:09:15 -07001479 if (self->IsExceptionPending()) {
1480 ScopedObjectAccess soa(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001481 LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
Ian Rogers50b35e22012-10-04 10:09:15 -07001482 << self->GetException()->Dump();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001483 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001484}
1485
Elliott Hughesa0e18062012-04-13 15:59:59 -07001486const CompiledInvokeStub* Compiler::FindInvokeStub(bool is_static, const char* shorty) const {
1487 const std::string key(MakeInvokeStubKey(is_static, shorty));
1488 return FindInvokeStub(key);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001489}
1490
Elliott Hughesa0e18062012-04-13 15:59:59 -07001491const CompiledInvokeStub* Compiler::FindInvokeStub(const std::string& key) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001492 MutexLock mu(Thread::Current(), compiled_invoke_stubs_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -07001493 InvokeStubTable::const_iterator it = compiled_invoke_stubs_.find(key);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001494 if (it == compiled_invoke_stubs_.end()) {
1495 return NULL;
Ian Rogers0571d352011-11-03 19:51:38 -07001496 } else {
1497 DCHECK(it->second != NULL);
1498 return it->second;
1499 }
1500}
1501
Elliott Hughesa0e18062012-04-13 15:59:59 -07001502void Compiler::InsertInvokeStub(const std::string& key,
Ian Rogers0571d352011-11-03 19:51:38 -07001503 const CompiledInvokeStub* compiled_invoke_stub) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001504 MutexLock mu(Thread::Current(), compiled_invoke_stubs_lock_);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001505 InvokeStubTable::iterator it = compiled_invoke_stubs_.find(key);
1506 if (it != compiled_invoke_stubs_.end()) {
1507 // Someone else won the race.
1508 delete compiled_invoke_stub;
1509 } else {
1510 compiled_invoke_stubs_.Put(key, compiled_invoke_stub);
1511 }
Ian Rogers0571d352011-11-03 19:51:38 -07001512}
1513
Logan Chien7a2a23a2012-06-06 11:01:00 +08001514#if defined(ART_USE_LLVM_COMPILER)
1515const CompiledInvokeStub* Compiler::FindProxyStub(const char* shorty) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001516 MutexLock mu(Thread::Current(), compiled_proxy_stubs_lock_);
Logan Chien7a2a23a2012-06-06 11:01:00 +08001517 ProxyStubTable::const_iterator it = compiled_proxy_stubs_.find(shorty);
1518 if (it == compiled_proxy_stubs_.end()) {
1519 return NULL;
1520 } else {
1521 DCHECK(it->second != NULL);
1522 return it->second;
1523 }
1524}
1525
1526void Compiler::InsertProxyStub(const char* shorty,
1527 const CompiledInvokeStub* compiled_proxy_stub) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001528 MutexLock mu(Thread::Current(), compiled_proxy_stubs_lock_);
Logan Chien7a2a23a2012-06-06 11:01:00 +08001529 InvokeStubTable::iterator it = compiled_proxy_stubs_.find(shorty);
1530 if (it != compiled_proxy_stubs_.end()) {
1531 // Someone else won the race.
1532 delete compiled_proxy_stub;
1533 } else {
1534 compiled_proxy_stubs_.Put(shorty, compiled_proxy_stub);
1535 }
1536}
1537#endif
1538
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001539CompiledClass* Compiler::GetCompiledClass(ClassReference ref) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001540 MutexLock mu(Thread::Current(), compiled_classes_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001541 ClassTable::const_iterator it = compiled_classes_.find(ref);
1542 if (it == compiled_classes_.end()) {
1543 return NULL;
1544 }
1545 CHECK(it->second != NULL);
1546 return it->second;
1547}
1548
Ian Rogers0571d352011-11-03 19:51:38 -07001549CompiledMethod* Compiler::GetCompiledMethod(MethodReference ref) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001550 MutexLock mu(Thread::Current(), compiled_methods_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -07001551 MethodTable::const_iterator it = compiled_methods_.find(ref);
1552 if (it == compiled_methods_.end()) {
1553 return NULL;
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001554 }
1555 CHECK(it->second != NULL);
1556 return it->second;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001557}
1558
buzbee2cfc6392012-05-07 14:51:40 -07001559#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_QUICK_COMPILER)
Logan Chien8b977d32012-02-21 19:14:55 +08001560void Compiler::SetBitcodeFileName(std::string const& filename) {
Logan Chien106b2a02012-03-18 04:41:38 +08001561 typedef void (*SetBitcodeFileNameFn)(Compiler&, std::string const&);
1562
1563 SetBitcodeFileNameFn set_bitcode_file_name =
1564 FindFunction<SetBitcodeFileNameFn>(MakeCompilerSoName(instruction_set_),
1565 compiler_library_,
1566 "compilerLLVMSetBitcodeFileName");
1567
1568 set_bitcode_file_name(*this, filename);
Logan Chien8b977d32012-02-21 19:14:55 +08001569}
buzbee2cfc6392012-05-07 14:51:40 -07001570#endif
Logan Chienf7015fd2012-03-18 01:19:37 +08001571
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001572} // namespace art