blob: ea343c4b3deed4dde03e886e28e55739c7903578 [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
Brian Carlstrom27ec9612011-09-19 20:20:38 -070021#include <sys/mman.h>
Elliott Hughesd9c67be2012-02-02 19:54:06 -080022#include <unistd.h>
Brian Carlstrom27ec9612011-09-19 20:20:38 -070023
Brian Carlstrom2cc022b2011-08-25 10:05:39 -070024#include "assembler.h"
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070025#include "class_linker.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070026#include "class_loader.h"
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070027#include "dex_cache.h"
Brian Carlstrome7d856b2012-01-11 18:10:55 -080028#include "dex_verifier.h"
Brian Carlstrom2cc022b2011-08-25 10:05:39 -070029#include "jni_compiler.h"
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -070030#include "jni_internal.h"
Brian Carlstrom3320cf42011-10-04 14:58:28 -070031#include "oat_file.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080032#include "object_utils.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070033#include "runtime.h"
Brian Carlstrom3320cf42011-10-04 14:58:28 -070034#include "stl_util.h"
Elliott Hughes601a1232012-02-02 17:47:38 -080035#include "timing_logger.h"
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070036
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070037namespace art {
38
Elliott Hughes11d1b0c2012-01-23 16:57:47 -080039CompiledMethod* oatCompileMethod(const Compiler& compiler, const DexFile::CodeItem* code_item,
40 uint32_t access_flags, uint32_t method_idx,
41 const ClassLoader* class_loader,
42 const DexFile& dex_file, InstructionSet);
43
Shih-wei Liaoc486c112011-09-13 16:43:52 -070044namespace arm {
Ian Rogersbdb03912011-09-14 00:55:44 -070045 ByteArray* CreateAbstractMethodErrorStub();
Ian Rogers0571d352011-11-03 19:51:38 -070046 CompiledInvokeStub* ArmCreateInvokeStub(bool is_static, const char* shorty);
Ian Rogers1cb0a1d2011-10-06 15:24:35 -070047 ByteArray* ArmCreateResolutionTrampoline(Runtime::TrampolineType type);
Elliott Hughes8add92d2012-01-18 18:18:43 -080048 ByteArray* CreateJniDlsymLookupStub();
Shih-wei Liaoc486c112011-09-13 16:43:52 -070049}
Shih-wei Liaoc486c112011-09-13 16:43:52 -070050namespace x86 {
Ian Rogersbdb03912011-09-14 00:55:44 -070051 ByteArray* CreateAbstractMethodErrorStub();
Ian Rogers0571d352011-11-03 19:51:38 -070052 CompiledInvokeStub* X86CreateInvokeStub(bool is_static, const char* shorty);
Ian Rogers1cb0a1d2011-10-06 15:24:35 -070053 ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type);
Elliott Hughes8add92d2012-01-18 18:18:43 -080054 ByteArray* CreateJniDlsymLookupStub();
Brian Carlstrome24fa612011-09-29 00:53:55 -070055}
56
Brian Carlstromae826982011-11-09 01:33:42 -080057Compiler::Compiler(InstructionSet instruction_set,
58 bool image,
59 const std::set<std::string>* image_classes)
Brian Carlstromaded5f72011-10-07 17:15:04 -070060 : instruction_set_(instruction_set),
61 jni_compiler_(instruction_set),
Elliott Hughesc225caa2012-02-03 15:43:37 -080062 compiled_classes_lock_("compiled classes lock"),
63 compiled_methods_lock_("compiled method lock"),
64 compiled_invoke_stubs_lock_("compiled invoke stubs lock"),
Brian Carlstromaded5f72011-10-07 17:15:04 -070065 image_(image),
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080066 image_classes_(image_classes) {
Brian Carlstrom25c33252011-09-18 15:58:35 -070067 CHECK(!Runtime::Current()->IsStarted());
Brian Carlstromae826982011-11-09 01:33:42 -080068 if (!image_) {
69 CHECK(image_classes_ == NULL);
70 }
Shih-wei Liaoc486c112011-09-13 16:43:52 -070071}
72
Brian Carlstrom3320cf42011-10-04 14:58:28 -070073Compiler::~Compiler() {
Elliott Hughesc225caa2012-02-03 15:43:37 -080074 {
75 MutexLock mu(compiled_classes_lock_);
76 STLDeleteValues(&compiled_classes_);
77 }
78 {
79 MutexLock mu(compiled_methods_lock_);
80 STLDeleteValues(&compiled_methods_);
81 }
82 {
83 MutexLock mu(compiled_invoke_stubs_lock_);
84 STLDeleteValues(&compiled_invoke_stubs_);
Elliott Hughesbb551fa2012-01-25 16:35:29 -080085 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -070086}
87
Ian Rogers1cb0a1d2011-10-06 15:24:35 -070088ByteArray* Compiler::CreateResolutionStub(InstructionSet instruction_set,
89 Runtime::TrampolineType type) {
Ian Rogersad25ac52011-10-04 19:13:33 -070090 if (instruction_set == kX86) {
Ian Rogers1cb0a1d2011-10-06 15:24:35 -070091 return x86::X86CreateResolutionTrampoline(type);
Ian Rogersad25ac52011-10-04 19:13:33 -070092 } else {
93 CHECK(instruction_set == kArm || instruction_set == kThumb2);
94 // Generates resolution stub using ARM instruction set
Ian Rogers1cb0a1d2011-10-06 15:24:35 -070095 return arm::ArmCreateResolutionTrampoline(type);
Ian Rogersad25ac52011-10-04 19:13:33 -070096 }
97}
98
Elliott Hughes8add92d2012-01-18 18:18:43 -080099ByteArray* Compiler::CreateJniDlsymLookupStub(InstructionSet instruction_set) {
Ian Rogers169c9a72011-11-13 20:13:17 -0800100 switch (instruction_set) {
101 case kArm:
102 case kThumb2:
Elliott Hughes8add92d2012-01-18 18:18:43 -0800103 return arm::CreateJniDlsymLookupStub();
Ian Rogers169c9a72011-11-13 20:13:17 -0800104 case kX86:
Elliott Hughes8add92d2012-01-18 18:18:43 -0800105 return x86::CreateJniDlsymLookupStub();
Ian Rogers169c9a72011-11-13 20:13:17 -0800106 default:
Elliott Hughesba8eee12012-01-24 20:25:24 -0800107 LOG(FATAL) << "Unknown InstructionSet: " << static_cast<int>(instruction_set);
Ian Rogers169c9a72011-11-13 20:13:17 -0800108 return NULL;
109 }
110}
111
Ian Rogersad25ac52011-10-04 19:13:33 -0700112ByteArray* Compiler::CreateAbstractMethodErrorStub(InstructionSet instruction_set) {
113 if (instruction_set == kX86) {
114 return x86::CreateAbstractMethodErrorStub();
115 } else {
116 CHECK(instruction_set == kArm || instruction_set == kThumb2);
117 // Generates resolution stub using ARM instruction set
118 return arm::CreateAbstractMethodErrorStub();
119 }
120}
121
Jesse Wilson254db0f2011-11-16 16:44:11 -0500122void Compiler::CompileAll(const ClassLoader* class_loader,
Brian Carlstromae826982011-11-09 01:33:42 -0800123 const std::vector<const DexFile*>& dex_files) {
Brian Carlstrom25c33252011-09-18 15:58:35 -0700124 DCHECK(!Runtime::Current()->IsStarted());
Brian Carlstromae826982011-11-09 01:33:42 -0800125
Elliott Hughes601a1232012-02-02 17:47:38 -0800126 TimingLogger timings("compiler");
127
128 PreCompile(class_loader, dex_files, timings);
129
Brian Carlstromae826982011-11-09 01:33:42 -0800130 Compile(class_loader, dex_files);
Elliott Hughes601a1232012-02-02 17:47:38 -0800131 timings.AddSplit("Compile");
132
Brian Carlstromae826982011-11-09 01:33:42 -0800133 PostCompile(class_loader, dex_files);
Elliott Hughes601a1232012-02-02 17:47:38 -0800134 timings.AddSplit("PostCompile");
135
136 if (timings.GetTotalNs() > MsToNs(1000)) {
137 timings.Dump();
138 }
Brian Carlstrom8a487412011-08-29 20:08:52 -0700139}
140
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700141void Compiler::CompileOne(const Method* method) {
Brian Carlstrom25c33252011-09-18 15:58:35 -0700142 DCHECK(!Runtime::Current()->IsStarted());
Brian Carlstromae826982011-11-09 01:33:42 -0800143
Brian Carlstrom8a487412011-08-29 20:08:52 -0700144 const ClassLoader* class_loader = method->GetDeclaringClass()->GetClassLoader();
Brian Carlstromae826982011-11-09 01:33:42 -0800145
Ian Rogers0571d352011-11-03 19:51:38 -0700146 // Find the dex_file
147 const DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
148 const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
Brian Carlstromae826982011-11-09 01:33:42 -0800149 std::vector<const DexFile*> dex_files;
150 dex_files.push_back(&dex_file);
151
Elliott Hughes601a1232012-02-02 17:47:38 -0800152 TimingLogger timings("CompileOne");
153 PreCompile(class_loader, dex_files, timings);
Brian Carlstromae826982011-11-09 01:33:42 -0800154
Ian Rogers0571d352011-11-03 19:51:38 -0700155 uint32_t method_idx = method->GetDexMethodIndex();
Ian Rogersa3760aa2011-11-14 14:32:37 -0800156 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
157 CompileMethod(code_item, method->GetAccessFlags(), method_idx, class_loader, dex_file);
Brian Carlstromae826982011-11-09 01:33:42 -0800158
159 PostCompile(class_loader, dex_files);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700160}
161
Brian Carlstromae826982011-11-09 01:33:42 -0800162void Compiler::Resolve(const ClassLoader* class_loader,
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800163 const std::vector<const DexFile*>& dex_files, TimingLogger& timings) {
Brian Carlstromae826982011-11-09 01:33:42 -0800164 for (size_t i = 0; i != dex_files.size(); ++i) {
165 const DexFile* dex_file = dex_files[i];
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700166 CHECK(dex_file != NULL);
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800167 ResolveDexFile(class_loader, *dex_file, timings);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700168 }
169}
170
Brian Carlstromae826982011-11-09 01:33:42 -0800171void Compiler::PreCompile(const ClassLoader* class_loader,
Elliott Hughes601a1232012-02-02 17:47:38 -0800172 const std::vector<const DexFile*>& dex_files, TimingLogger& timings) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800173 Resolve(class_loader, dex_files, timings);
Elliott Hughes601a1232012-02-02 17:47:38 -0800174
Brian Carlstromae826982011-11-09 01:33:42 -0800175 Verify(class_loader, dex_files);
Elliott Hughes601a1232012-02-02 17:47:38 -0800176 timings.AddSplit("PreCompile.Verify");
177
Brian Carlstromae826982011-11-09 01:33:42 -0800178 InitializeClassesWithoutClinit(class_loader, dex_files);
Elliott Hughes601a1232012-02-02 17:47:38 -0800179 timings.AddSplit("PreCompile.InitializeClassesWithoutClinit");
Brian Carlstromae826982011-11-09 01:33:42 -0800180}
181
182void Compiler::PostCompile(const ClassLoader* class_loader,
183 const std::vector<const DexFile*>& dex_files) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -0800184 SetGcMaps(class_loader, dex_files);
Brian Carlstromae826982011-11-09 01:33:42 -0800185 SetCodeAndDirectMethods(dex_files);
186}
187
188bool Compiler::IsImageClass(const std::string& descriptor) const {
189 if (image_classes_ == NULL) {
190 return true;
191 }
192 return image_classes_->find(descriptor) != image_classes_->end();
193}
194
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800195bool Compiler::CanAssumeTypeIsPresentInDexCache(const DexCache* dex_cache,
196 uint32_t type_idx) const {
197 if (!IsImage()) {
198 return false;
199 }
200 Class* resolved_class = dex_cache->GetResolvedTypes()->Get(type_idx);
201 if (resolved_class == NULL) {
202 return false;
203 }
204 return IsImageClass(ClassHelper(resolved_class).GetDescriptor());
205}
206
Brian Carlstrom5ead0952011-11-28 22:55:52 -0800207// Return true if the class should be skipped during compilation. We
208// never skip classes in the boot class loader. However, if we have a
209// non-boot class loader and we can resolve the class in the boot
210// class loader, we do skip the class. This happens if an app bundles
211// classes found in the boot classpath. Since at runtime we will
212// select the class from the boot classpath, do not attempt to resolve
213// or compile it now.
214static bool SkipClass(const ClassLoader* class_loader,
215 const DexFile& dex_file,
216 const DexFile::ClassDef& class_def) {
217 if (class_loader == NULL) {
218 return false;
219 }
220 const char* descriptor = dex_file.GetClassDescriptor(class_def);
221 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
222 Class* klass = class_linker->FindClass(descriptor, NULL);
223 if (klass == NULL) {
224 Thread* self = Thread::Current();
225 CHECK(self->IsExceptionPending());
226 self->ClearException();
227 return false;
228 }
229 return true;
230}
231
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800232struct Context {
233 ClassLinker* class_linker;
234 const ClassLoader* class_loader;
Elliott Hughesc225caa2012-02-03 15:43:37 -0800235 Compiler* compiler;
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800236 DexCache* dex_cache;
237 const DexFile* dex_file;
238};
239
240typedef void Callback(Context* context, size_t index);
241
242class WorkerThread {
243 public:
244 WorkerThread(Context* context, size_t begin, size_t end, Callback callback, size_t stripe)
245 : context_(context), begin_(begin), end_(end), callback_(callback), stripe_(stripe) {
246 CHECK_PTHREAD_CALL(pthread_create, (&pthread_, NULL, &Init, this), "compiler worker thread");
247 }
248
249 ~WorkerThread() {
250 CHECK_PTHREAD_CALL(pthread_join, (pthread_, NULL), "compiler worker shutdown");
251 }
252
253 private:
254 static void* Init(void* arg) {
255 WorkerThread* worker = reinterpret_cast<WorkerThread*>(arg);
256 Runtime* runtime = Runtime::Current();
257 runtime->AttachCurrentThread("Compiler Worker", true);
258 Thread::Current()->SetState(Thread::kRunnable);
259 worker->Run();
260 Thread::Current()->SetState(Thread::kNative);
261 runtime->DetachCurrentThread();
262 return NULL;
263 }
264
265 void Run() {
266 for (size_t i = begin_; i < end_; i += stripe_) {
267 callback_(context_, i);
268 }
269 }
270
271 pthread_t pthread_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800272
273 Context* context_;
274 size_t begin_;
275 size_t end_;
276 Callback* callback_;
277 size_t stripe_;
278};
279
280class Workers {
281 public:
282 Workers(Context* context, size_t begin, size_t end, Callback callback) {
283 const size_t thread_count = static_cast<size_t>(sysconf(_SC_NPROCESSORS_ONLN));
284 for (size_t i = 0; i < thread_count; ++i) {
285 threads_.push_back(new WorkerThread(context, begin + i, end, callback, thread_count));
286 }
287 }
288
289 ~Workers() {
Elliott Hughesff738062012-02-03 15:00:42 -0800290 // Switch to kVmWait while we're blocked waiting for the other threads to finish.
291 ScopedThreadStateChange tsc(Thread::Current(), Thread::kVmWait);
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800292 STLDeleteElements(&threads_);
293 }
294
295 private:
296 std::vector<WorkerThread*> threads_;
297};
298
299static void ResolveClassFieldsAndMethods(Context* context, size_t class_def_index) {
300 const DexFile& dex_file = *context->dex_file;
301
302 // Method and Field are the worst. We can't resolve without either
303 // context from the code use (to disambiguate virtual vs direct
304 // method and instance vs static field) or from class
305 // definitions. While the compiler will resolve what it can as it
306 // needs it, here we try to resolve fields and methods used in class
307 // definitions, since many of them many never be referenced by
308 // generated code.
309 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
310 if (SkipClass(context->class_loader, dex_file, class_def)) {
311 return;
312 }
313
314 // Note the class_data pointer advances through the headers,
315 // static fields, instance fields, direct methods, and virtual
316 // methods.
317 const byte* class_data = dex_file.GetClassData(class_def);
318 if (class_data == NULL) {
319 // empty class such as a marker interface
320 return;
321 }
Brian Carlstrom5ead0952011-11-28 22:55:52 -0800322 Thread* self = Thread::Current();
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800323 ClassLinker* class_linker = context->class_linker;
324 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
325 ClassDataItemIterator it(dex_file, class_data);
326 while (it.HasNextStaticField()) {
327 Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
328 context->class_loader, true);
329 if (field == NULL) {
330 CHECK(self->IsExceptionPending());
331 self->ClearException();
332 }
333 it.Next();
334 }
335 while (it.HasNextInstanceField()) {
336 Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
337 context->class_loader, false);
338 if (field == NULL) {
339 CHECK(self->IsExceptionPending());
340 self->ClearException();
341 }
342 it.Next();
343 }
344 while (it.HasNextDirectMethod()) {
345 Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
346 context->class_loader, true);
347 if (method == NULL) {
348 CHECK(self->IsExceptionPending());
349 self->ClearException();
350 }
351 it.Next();
352 }
353 while (it.HasNextVirtualMethod()) {
354 Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
355 context->class_loader, false);
356 if (method == NULL) {
357 CHECK(self->IsExceptionPending());
358 self->ClearException();
359 }
360 it.Next();
361 }
362 DCHECK(!it.HasNext());
363}
364
365static void ResolveType(Context* context, size_t type_idx) {
366 // Class derived values are more complicated, they require the linker and loader.
367 Thread* self = Thread::Current();
368 ClassLinker* class_linker = context->class_linker;
369 const DexFile& dex_file = *context->dex_file;
370 Class* klass = class_linker->ResolveType(dex_file, type_idx, context->dex_cache, context->class_loader);
371 if (klass == NULL) {
372 CHECK(self->IsExceptionPending());
373 Thread::Current()->ClearException();
374 }
375}
376
377void Compiler::ResolveDexFile(const ClassLoader* class_loader, const DexFile& dex_file, TimingLogger& timings) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700378 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700379 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700380
Brian Carlstromae826982011-11-09 01:33:42 -0800381 // Strings are easy in that they always are simply resolved to literals in the same file
382 if (image_ && image_classes_ == NULL) {
383 // TODO: Add support for loading strings referenced by image_classes_
384 // See also Compiler::CanAssumeTypeIsPresentInDexCache.
Brian Carlstromaded5f72011-10-07 17:15:04 -0700385 for (size_t string_idx = 0; string_idx < dex_cache->NumStrings(); string_idx++) {
386 class_linker->ResolveString(dex_file, string_idx, dex_cache);
387 }
Elliott Hughesff738062012-02-03 15:00:42 -0800388 timings.AddSplit("Resolve " + dex_file.GetLocation() + " Strings");
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700389 }
390
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800391 Context context;
392 context.class_linker = class_linker;
393 context.class_loader = class_loader;
394 context.dex_cache = dex_cache;
395 context.dex_file = &dex_file;
396
397 {
398 Workers workers(&context, 0, dex_cache->NumResolvedTypes(), ResolveType);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700399 }
Elliott Hughesff738062012-02-03 15:00:42 -0800400 timings.AddSplit("Resolve " + dex_file.GetLocation() + " Types");
Brian Carlstrom845490b2011-09-19 15:56:53 -0700401
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800402 {
403 Workers workers(&context, 0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700404 }
Elliott Hughesff738062012-02-03 15:00:42 -0800405 timings.AddSplit("Resolve " + dex_file.GetLocation() + " MethodsAndFields");
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700406}
407
Brian Carlstromae826982011-11-09 01:33:42 -0800408void Compiler::Verify(const ClassLoader* class_loader,
409 const std::vector<const DexFile*>& dex_files) {
410 for (size_t i = 0; i != dex_files.size(); ++i) {
411 const DexFile* dex_file = dex_files[i];
jeffhao98eacac2011-09-14 16:11:53 -0700412 CHECK(dex_file != NULL);
413 VerifyDexFile(class_loader, *dex_file);
414 }
415}
416
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800417static void VerifyClass(Context* context, size_t class_def_index) {
418 const DexFile::ClassDef& class_def = context->dex_file->GetClassDef(class_def_index);
419 const char* descriptor = context->dex_file->GetClassDescriptor(class_def);
420 Class* klass = context->class_linker->FindClass(descriptor, context->class_loader);
421 if (klass == NULL) {
422 Thread* self = Thread::Current();
423 CHECK(self->IsExceptionPending());
424 self->ClearException();
425 return;
426 }
427 CHECK(klass->IsResolved()) << PrettyClass(klass);
428 context->class_linker->VerifyClass(klass);
429
430 if (klass->IsErroneous()) {
431 // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
432 CHECK(Thread::Current()->IsExceptionPending());
433 Thread::Current()->ClearException();
434 // We want to try verification again at run-time, so move back into the resolved state.
435 klass->SetStatus(Class::kStatusResolved);
436 }
437
438 CHECK(klass->IsVerified() || klass->IsResolved()) << PrettyClass(klass);
439 CHECK(!Thread::Current()->IsExceptionPending()) << PrettyTypeOf(Thread::Current()->GetException());
440}
441
jeffhao98eacac2011-09-14 16:11:53 -0700442void Compiler::VerifyDexFile(const ClassLoader* class_loader, const DexFile& dex_file) {
jeffhaob4df5142011-09-19 20:25:32 -0700443 dex_file.ChangePermissions(PROT_READ | PROT_WRITE);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -0700444
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800445 Context context;
446 context.class_linker = Runtime::Current()->GetClassLinker();
447 context.class_loader = class_loader;
448 context.dex_file = &dex_file;
Elliott Hughesb0bbbab2012-02-03 16:26:19 -0800449 {
450 Workers workers(&context, 0, dex_file.NumClassDefs(), VerifyClass);
451 }
Elliott Hughesd9cdfe92011-10-06 16:09:04 -0700452
jeffhaob4df5142011-09-19 20:25:32 -0700453 dex_file.ChangePermissions(PROT_READ);
Brian Carlstroma5a97a22011-09-15 14:08:49 -0700454}
455
Brian Carlstromae826982011-11-09 01:33:42 -0800456void Compiler::InitializeClassesWithoutClinit(const ClassLoader* class_loader,
457 const std::vector<const DexFile*>& dex_files) {
458 for (size_t i = 0; i != dex_files.size(); ++i) {
459 const DexFile* dex_file = dex_files[i];
Brian Carlstroma5a97a22011-09-15 14:08:49 -0700460 CHECK(dex_file != NULL);
461 InitializeClassesWithoutClinit(class_loader, *dex_file);
462 }
463}
464
465void Compiler::InitializeClassesWithoutClinit(const ClassLoader* class_loader, const DexFile& dex_file) {
466 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Brian Carlstromffca45d2011-09-16 12:10:49 -0700467 for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs(); class_def_index++) {
468 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
Brian Carlstroma5a97a22011-09-15 14:08:49 -0700469 const char* descriptor = dex_file.GetClassDescriptor(class_def);
470 Class* klass = class_linker->FindClass(descriptor, class_loader);
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700471 if (klass != NULL) {
472 class_linker->EnsureInitialized(klass, false);
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800473 // record the final class status if necessary
474 Class::Status status = klass->GetStatus();
475 ClassReference ref(&dex_file, class_def_index);
Elliott Hughesc225caa2012-02-03 15:43:37 -0800476 MutexLock mu(compiled_classes_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800477 CompiledClass* compiled_class = GetCompiledClass(ref);
478 if (compiled_class == NULL) {
479 compiled_class = new CompiledClass(status);
480 compiled_classes_[ref] = compiled_class;
481 } else {
482 DCHECK_EQ(status, compiled_class->GetStatus());
483 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700484 }
485 // clear any class not found or verification exceptions
486 Thread::Current()->ClearException();
Brian Carlstromffca45d2011-09-16 12:10:49 -0700487 }
488
489 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
490 for (size_t type_idx = 0; type_idx < dex_cache->NumResolvedTypes(); type_idx++) {
491 Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700492 if (klass == NULL) {
493 Thread::Current()->ClearException();
494 } else if (klass->IsInitialized()) {
Brian Carlstromffca45d2011-09-16 12:10:49 -0700495 dex_cache->GetInitializedStaticStorage()->Set(type_idx, klass);
496 }
jeffhao98eacac2011-09-14 16:11:53 -0700497 }
498}
499
Brian Carlstromae826982011-11-09 01:33:42 -0800500void Compiler::Compile(const ClassLoader* class_loader,
501 const std::vector<const DexFile*>& dex_files) {
502 for (size_t i = 0; i != dex_files.size(); ++i) {
503 const DexFile* dex_file = dex_files[i];
Brian Carlstrom83db7722011-08-26 17:32:56 -0700504 CHECK(dex_file != NULL);
505 CompileDexFile(class_loader, *dex_file);
506 }
507}
508
Elliott Hughesc225caa2012-02-03 15:43:37 -0800509void Compiler::CompileClass(Context* context, size_t class_def_index) {
510 const ClassLoader* class_loader = context->class_loader;
511 const DexFile& dex_file = *context->dex_file;
512 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
Brian Carlstrom5ead0952011-11-28 22:55:52 -0800513 if (SkipClass(class_loader, dex_file, class_def)) {
514 return;
515 }
Ian Rogers0571d352011-11-03 19:51:38 -0700516 const byte* class_data = dex_file.GetClassData(class_def);
517 if (class_data == NULL) {
518 // empty class, probably a marker interface
519 return;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700520 }
Ian Rogers0571d352011-11-03 19:51:38 -0700521 ClassDataItemIterator it(dex_file, class_data);
522 // Skip fields
523 while (it.HasNextStaticField()) {
524 it.Next();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700525 }
Ian Rogers0571d352011-11-03 19:51:38 -0700526 while (it.HasNextInstanceField()) {
527 it.Next();
528 }
529 // Compile direct methods
530 while (it.HasNextDirectMethod()) {
Elliott Hughesc225caa2012-02-03 15:43:37 -0800531 context->compiler->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
532 it.GetMemberIndex(), class_loader, dex_file);
Ian Rogers0571d352011-11-03 19:51:38 -0700533 it.Next();
534 }
535 // Compile virtual methods
536 while (it.HasNextVirtualMethod()) {
Elliott Hughesc225caa2012-02-03 15:43:37 -0800537 context->compiler->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
538 it.GetMemberIndex(), class_loader, dex_file);
Ian Rogers0571d352011-11-03 19:51:38 -0700539 it.Next();
540 }
541 DCHECK(!it.HasNext());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700542}
543
Elliott Hughesc225caa2012-02-03 15:43:37 -0800544void Compiler::CompileDexFile(const ClassLoader* class_loader, const DexFile& dex_file) {
545 Context context;
546 context.class_loader = class_loader;
547 context.compiler = this;
548 context.dex_file = &dex_file;
549 {
550 Workers workers(&context, 0, dex_file.NumClassDefs(), Compiler::CompileClass);
551 }
552}
553
Ian Rogersa3760aa2011-11-14 14:32:37 -0800554void Compiler::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
555 uint32_t method_idx, const ClassLoader* class_loader,
556 const DexFile& dex_file) {
Elliott Hughesf09afe82011-10-16 14:24:21 -0700557 CompiledMethod* compiled_method = NULL;
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800558 uint64_t start_ns = NanoTime();
Ian Rogers169c9a72011-11-13 20:13:17 -0800559 if ((access_flags & kAccNative) != 0) {
560 compiled_method = jni_compiler_.Compile(access_flags, method_idx, class_loader, dex_file);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700561 CHECK(compiled_method != NULL);
Ian Rogers169c9a72011-11-13 20:13:17 -0800562 } else if ((access_flags & kAccAbstract) != 0) {
Brian Carlstrom2cc022b2011-08-25 10:05:39 -0700563 } else {
Ian Rogersa3760aa2011-11-14 14:32:37 -0800564 compiled_method = oatCompileMethod(*this, code_item, access_flags, method_idx, class_loader,
565 dex_file, kThumb2);
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800566 CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
567 }
Ian Rogers3bb17a62012-01-27 23:56:44 -0800568 uint64_t duration_ns = NanoTime() - start_ns;
buzbee5abfa3e2012-01-31 17:01:43 -0800569 if (duration_ns > MsToNs(100)) {
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800570 LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
Ian Rogers3bb17a62012-01-27 23:56:44 -0800571 << " took " << PrettyDuration(duration_ns);
Elliott Hughesf09afe82011-10-16 14:24:21 -0700572 }
573
574 if (compiled_method != NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -0700575 MethodReference ref(&dex_file, method_idx);
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800576 CHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
Elliott Hughesc225caa2012-02-03 15:43:37 -0800577 MutexLock mu(compiled_methods_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -0700578 compiled_methods_[ref] = compiled_method;
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800579 DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
Brian Carlstrom2cc022b2011-08-25 10:05:39 -0700580 }
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -0700581
Ian Rogers0571d352011-11-03 19:51:38 -0700582 const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
Ian Rogers169c9a72011-11-13 20:13:17 -0800583 bool is_static = (access_flags & kAccStatic) != 0;
Ian Rogers0571d352011-11-03 19:51:38 -0700584 const CompiledInvokeStub* compiled_invoke_stub = FindInvokeStub(is_static, shorty);
585 if (compiled_invoke_stub == NULL) {
586 if (instruction_set_ == kX86) {
Elliott Hughes11d1b0c2012-01-23 16:57:47 -0800587 compiled_invoke_stub = ::art::x86::X86CreateInvokeStub(is_static, shorty);
Ian Rogers0571d352011-11-03 19:51:38 -0700588 } else {
589 CHECK(instruction_set_ == kArm || instruction_set_ == kThumb2);
590 // Generates invocation stub using ARM instruction set
Elliott Hughes11d1b0c2012-01-23 16:57:47 -0800591 compiled_invoke_stub = ::art::arm::ArmCreateInvokeStub(is_static, shorty);
Ian Rogers0571d352011-11-03 19:51:38 -0700592 }
593 CHECK(compiled_invoke_stub != NULL);
594 InsertInvokeStub(is_static, shorty, compiled_invoke_stub);
Ian Rogers2c8f6532011-09-02 17:16:34 -0700595 }
Ian Rogers0571d352011-11-03 19:51:38 -0700596 CHECK(!Thread::Current()->IsExceptionPending()) << PrettyMethod(method_idx, dex_file);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700597}
598
Ian Rogers0571d352011-11-03 19:51:38 -0700599static std::string MakeInvokeStubKey(bool is_static, const char* shorty) {
600 std::string key(shorty);
601 if (is_static) {
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800602 key += "$"; // Must not be a shorty type character.
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700603 }
Ian Rogers0571d352011-11-03 19:51:38 -0700604 return key;
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700605}
606
Ian Rogers0571d352011-11-03 19:51:38 -0700607const CompiledInvokeStub* Compiler::FindInvokeStub(bool is_static, const char* shorty) const {
Elliott Hughesc225caa2012-02-03 15:43:37 -0800608 MutexLock mu(compiled_invoke_stubs_lock_);
Elliott Hughes95572412011-12-13 18:14:20 -0800609 const std::string key(MakeInvokeStubKey(is_static, shorty));
Ian Rogers0571d352011-11-03 19:51:38 -0700610 InvokeStubTable::const_iterator it = compiled_invoke_stubs_.find(key);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700611 if (it == compiled_invoke_stubs_.end()) {
612 return NULL;
Ian Rogers0571d352011-11-03 19:51:38 -0700613 } else {
614 DCHECK(it->second != NULL);
615 return it->second;
616 }
617}
618
619void Compiler::InsertInvokeStub(bool is_static, const char* shorty,
620 const CompiledInvokeStub* compiled_invoke_stub) {
Elliott Hughesc225caa2012-02-03 15:43:37 -0800621 MutexLock mu(compiled_invoke_stubs_lock_);
Elliott Hughes95572412011-12-13 18:14:20 -0800622 std::string key(MakeInvokeStubKey(is_static, shorty));
Ian Rogers0571d352011-11-03 19:51:38 -0700623 compiled_invoke_stubs_[key] = compiled_invoke_stub;
624}
625
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800626CompiledClass* Compiler::GetCompiledClass(ClassReference ref) const {
Elliott Hughesc225caa2012-02-03 15:43:37 -0800627 MutexLock mu(compiled_classes_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800628 ClassTable::const_iterator it = compiled_classes_.find(ref);
629 if (it == compiled_classes_.end()) {
630 return NULL;
631 }
632 CHECK(it->second != NULL);
633 return it->second;
634}
635
Ian Rogers0571d352011-11-03 19:51:38 -0700636CompiledMethod* Compiler::GetCompiledMethod(MethodReference ref) const {
Elliott Hughesc225caa2012-02-03 15:43:37 -0800637 MutexLock mu(compiled_methods_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -0700638 MethodTable::const_iterator it = compiled_methods_.find(ref);
639 if (it == compiled_methods_.end()) {
640 return NULL;
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700641 }
642 CHECK(it->second != NULL);
643 return it->second;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700644}
645
Brian Carlstrome7d856b2012-01-11 18:10:55 -0800646void Compiler::SetGcMaps(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files) {
647 for (size_t i = 0; i != dex_files.size(); ++i) {
648 const DexFile* dex_file = dex_files[i];
649 CHECK(dex_file != NULL);
650 SetGcMapsDexFile(class_loader, *dex_file);
651 }
652}
653
654void Compiler::SetGcMapsDexFile(const ClassLoader* class_loader, const DexFile& dex_file) {
655 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
656 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
657 for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs(); class_def_index++) {
658 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
659 const char* descriptor = dex_file.GetClassDescriptor(class_def);
660 Class* klass = class_linker->FindClass(descriptor, class_loader);
661 if (klass == NULL || !klass->IsVerified()) {
662 Thread::Current()->ClearException();
663 continue;
664 }
665 const byte* class_data = dex_file.GetClassData(class_def);
666 if (class_data == NULL) {
667 // empty class such as a marker interface
668 continue;
669 }
670 ClassDataItemIterator it(dex_file, class_data);
671 while (it.HasNextStaticField()) {
672 it.Next();
673 }
674 while (it.HasNextInstanceField()) {
675 it.Next();
676 }
677 while (it.HasNextDirectMethod()) {
678 Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
679 class_loader, true);
680 SetGcMapsMethod(dex_file, method);
681 it.Next();
682 }
683 while (it.HasNextVirtualMethod()) {
684 Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
685 class_loader, false);
686 SetGcMapsMethod(dex_file, method);
687 it.Next();
688 }
689 }
690}
691
692void Compiler::SetGcMapsMethod(const DexFile& dex_file, Method* method) {
693 if (method == NULL) {
694 Thread::Current()->ClearException();
695 return;
696 }
697 uint16_t method_idx = method->GetDexMethodIndex();
698 MethodReference ref(&dex_file, method_idx);
699 CompiledMethod* compiled_method = GetCompiledMethod(ref);
700 if (compiled_method == NULL) {
701 return;
702 }
703 const std::vector<uint8_t>* gc_map = verifier::DexVerifier::GetGcMap(ref);
704 if (gc_map == NULL) {
705 return;
706 }
707 compiled_method->SetGcMap(*gc_map);
708}
709
Brian Carlstromae826982011-11-09 01:33:42 -0800710void Compiler::SetCodeAndDirectMethods(const std::vector<const DexFile*>& dex_files) {
711 for (size_t i = 0; i != dex_files.size(); ++i) {
712 const DexFile* dex_file = dex_files[i];
Brian Carlstrom83db7722011-08-26 17:32:56 -0700713 CHECK(dex_file != NULL);
Brian Carlstrom8a487412011-08-29 20:08:52 -0700714 SetCodeAndDirectMethodsDexFile(*dex_file);
Brian Carlstrom83db7722011-08-26 17:32:56 -0700715 }
716}
717
Brian Carlstrom8a487412011-08-29 20:08:52 -0700718void Compiler::SetCodeAndDirectMethodsDexFile(const DexFile& dex_file) {
Ian Rogersad25ac52011-10-04 19:13:33 -0700719 Runtime* runtime = Runtime::Current();
720 ClassLinker* class_linker = runtime->GetClassLinker();
Brian Carlstrom83db7722011-08-26 17:32:56 -0700721 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
Brian Carlstrom9cc262e2011-08-28 12:45:30 -0700722 CodeAndDirectMethods* code_and_direct_methods = dex_cache->GetCodeAndDirectMethods();
Brian Carlstrom1caa2c22011-08-28 13:02:33 -0700723 for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
Brian Carlstrom83db7722011-08-26 17:32:56 -0700724 Method* method = dex_cache->GetResolvedMethod(i);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700725 if (method == NULL || method->IsDirect()) {
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700726 Runtime::TrampolineType type = Runtime::GetTrampolineType(method);
727 ByteArray* res_trampoline = runtime->GetResolutionStubArray(type);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700728 code_and_direct_methods->SetResolvedDirectMethodTrampoline(i, res_trampoline);
Brian Carlstrom9cc262e2011-08-28 12:45:30 -0700729 } else {
730 // TODO: we currently leave the entry blank for resolved
731 // non-direct methods. we could put in an error stub.
Brian Carlstrom83db7722011-08-26 17:32:56 -0700732 }
733 }
734}
735
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700736} // namespace art