blob: f9af139d52d32b5d76e44478ed859ec0af9509b3 [file] [log] [blame]
Shih-wei Liaod1fec812012-02-13 09:51:10 -08001/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "compiler_llvm.h"
18
Shih-wei Liaoc4c98812012-03-10 21:55:51 -080019#include "class_linker.h"
Logan Chien8b977d32012-02-21 19:14:55 +080020#include "compilation_unit.h"
Logan Chienf7015fd2012-03-18 01:19:37 +080021#include "compiled_method.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080022#include "compiler.h"
Shih-wei Liaoc4c98812012-03-10 21:55:51 -080023#include "dex_cache.h"
Logan Chien0f0899a2012-03-23 10:48:18 +080024#include "elf_image.h"
Logan Chienf7015fd2012-03-18 01:19:37 +080025#include "elf_loader.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080026#include "ir_builder.h"
Logan Chien88894ee2012-02-13 16:42:22 +080027#include "jni_compiler.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080028#include "method_compiler.h"
Logan Chien4dd96f52012-02-29 01:26:58 +080029#include "oat_compilation_unit.h"
Logan Chien0c717dd2012-03-28 18:31:07 +080030#include "oat_file.h"
Logan Chien7f767612012-03-01 18:54:49 +080031#include "stl_util.h"
Logan Chienf04364f2012-02-10 12:01:39 +080032#include "upcall_compiler.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080033
Logan Chiendd7cf5b2012-03-01 12:55:19 +080034#include <llvm/LinkAllPasses.h>
35#include <llvm/LinkAllVMCore.h>
Logan Chien4c17dff2012-03-02 20:15:46 +080036#include <llvm/Support/CommandLine.h>
Logan Chien013b6f22012-03-02 17:20:33 +080037#include <llvm/Support/ManagedStatic.h>
Logan Chien8b977d32012-02-21 19:14:55 +080038#include <llvm/Support/TargetSelect.h>
39#include <llvm/Support/Threading.h>
40
Logan Chien013b6f22012-03-02 17:20:33 +080041namespace llvm {
42 extern bool TimePassesIsEnabled;
43}
44
Logan Chien4c17dff2012-03-02 20:15:46 +080045extern llvm::cl::opt<bool> EnableARMLongCalls;
46// NOTE: Although EnableARMLongCalls is defined in llvm/lib/Target/ARM/
47// ARMISelLowering.cpp, however, it is not in the llvm namespace.
48
Logan Chien8b977d32012-02-21 19:14:55 +080049
Shih-wei Liaofc34adb2012-03-07 08:51:44 -080050namespace {
Logan Chien8b977d32012-02-21 19:14:55 +080051
Shih-wei Liaofc34adb2012-03-07 08:51:44 -080052pthread_once_t llvm_initialized = PTHREAD_ONCE_INIT;
53
54void InitializeLLVM() {
Logan Chien013b6f22012-03-02 17:20:33 +080055 // NOTE: Uncomment following line to show the time consumption of LLVM passes
56 //llvm::TimePassesIsEnabled = true;
57
Logan Chien8b977d32012-02-21 19:14:55 +080058 // Initialize LLVM target, MC subsystem, asm printer, and asm parser
59 llvm::InitializeAllTargets();
60 llvm::InitializeAllTargetMCs();
61 llvm::InitializeAllAsmPrinters();
62 llvm::InitializeAllAsmParsers();
63 // TODO: Maybe we don't have to initialize "all" targets.
64
Logan Chien4c17dff2012-03-02 20:15:46 +080065 // Enable -arm-long-calls
66 EnableARMLongCalls = true;
67
Logan Chiendd7cf5b2012-03-01 12:55:19 +080068 // Initialize LLVM optimization passes
69 llvm::PassRegistry &registry = *llvm::PassRegistry::getPassRegistry();
70
71 llvm::initializeCore(registry);
72 llvm::initializeScalarOpts(registry);
73 llvm::initializeIPO(registry);
74 llvm::initializeAnalysis(registry);
75 llvm::initializeIPA(registry);
76 llvm::initializeTransformUtils(registry);
77 llvm::initializeInstCombine(registry);
78 llvm::initializeInstrumentation(registry);
79 llvm::initializeTarget(registry);
80
Logan Chien8b977d32012-02-21 19:14:55 +080081 // Initialize LLVM internal data structure for multithreading
82 llvm::llvm_start_multithreaded();
83}
84
Logan Chienf1306552012-03-16 11:17:53 +080085// The Guard to Shutdown LLVM
Logan Chienaeb53032012-03-18 02:29:38 +080086// llvm::llvm_shutdown_obj llvm_guard;
87// TODO: We are commenting out this line because this will cause SEGV from
88// time to time.
89// Two reasons: (1) the order of the destruction of static objects, or
90// (2) dlopen/dlclose side-effect on static objects.
Shih-wei Liaofc34adb2012-03-07 08:51:44 -080091
92} // anonymous namespace
93
94
95namespace art {
96namespace compiler_llvm {
Shih-wei Liaod1fec812012-02-13 09:51:10 -080097
98
Logan Chiene75a8cc2012-02-24 12:26:43 +080099llvm::Module* makeLLVMModuleContents(llvm::Module* module);
Logan Chien42e0e152012-01-13 15:42:36 +0800100
101
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800102CompilerLLVM::CompilerLLVM(Compiler* compiler, InstructionSet insn_set)
Shih-wei Liao5b8b1ed2012-02-23 23:48:21 -0800103 : compiler_(compiler), compiler_lock_("llvm_compiler_lock"),
Logan Chien7f767612012-03-01 18:54:49 +0800104 insn_set_(insn_set), curr_cunit_(NULL) {
Shih-wei Liaofc34adb2012-03-07 08:51:44 -0800105
106
107 // Initialize LLVM libraries
108 pthread_once(&llvm_initialized, InitializeLLVM);
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800109}
110
111
112CompilerLLVM::~CompilerLLVM() {
Logan Chien7f767612012-03-01 18:54:49 +0800113 STLDeleteElements(&cunits_);
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800114}
115
116
Logan Chience119062012-03-02 11:57:34 +0800117void CompilerLLVM::EnsureCompilationUnit() {
Logan Chience119062012-03-02 11:57:34 +0800118 compiler_lock_.AssertHeld();
Logan Chien7f767612012-03-01 18:54:49 +0800119
120 if (curr_cunit_ != NULL) {
121 return;
Logan Chien8b977d32012-02-21 19:14:55 +0800122 }
Logan Chien7f767612012-03-01 18:54:49 +0800123
124 // Allocate compilation unit
125 size_t cunit_idx = cunits_.size();
126
Logan Chien6546ec52012-03-17 20:08:29 +0800127 curr_cunit_ = new CompilationUnit(insn_set_, cunit_idx);
Logan Chien7f767612012-03-01 18:54:49 +0800128
Logan Chiende08e842012-03-21 00:34:12 +0800129 // Setup bitcode output filename
Logan Chien7f767612012-03-01 18:54:49 +0800130 if (IsBitcodeFileNameAvailable()) {
131 curr_cunit_->SetBitcodeFileName(
132 StringPrintf("%s-%zu", bitcode_filename_.c_str(), cunit_idx));
133 }
134
135 // Register compilation unit
136 cunits_.push_back(curr_cunit_);
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800137}
138
139
Logan Chien7f767612012-03-01 18:54:49 +0800140void CompilerLLVM::MaterializeRemainder() {
Logan Chien8b977d32012-02-21 19:14:55 +0800141 MutexLock GUARD(compiler_lock_);
Logan Chien7f767612012-03-01 18:54:49 +0800142 if (curr_cunit_ != NULL) {
Logan Chience119062012-03-02 11:57:34 +0800143 Materialize();
Logan Chien7f767612012-03-01 18:54:49 +0800144 }
145}
Logan Chien8b977d32012-02-21 19:14:55 +0800146
Logan Chien8b977d32012-02-21 19:14:55 +0800147
Logan Chien7f767612012-03-01 18:54:49 +0800148void CompilerLLVM::MaterializeIfThresholdReached() {
149 MutexLock GUARD(compiler_lock_);
150 if (curr_cunit_ != NULL && curr_cunit_->IsMaterializeThresholdReached()) {
Logan Chience119062012-03-02 11:57:34 +0800151 Materialize();
Logan Chien7f767612012-03-01 18:54:49 +0800152 }
153}
154
155
Logan Chience119062012-03-02 11:57:34 +0800156void CompilerLLVM::Materialize() {
157 compiler_lock_.AssertHeld();
158
Logan Chien7f767612012-03-01 18:54:49 +0800159 DCHECK(curr_cunit_ != NULL);
160 DCHECK(!curr_cunit_->IsMaterialized());
161
162 // Write bitcode to file when filename is set
163 if (IsBitcodeFileNameAvailable()) {
164 curr_cunit_->WriteBitcodeToFile();
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800165 }
166
Logan Chien8b977d32012-02-21 19:14:55 +0800167 // Materialize the llvm::Module into ELF object file
Logan Chien7f767612012-03-01 18:54:49 +0800168 curr_cunit_->Materialize();
Logan Chien8b977d32012-02-21 19:14:55 +0800169
Logan Chienf7015fd2012-03-18 01:19:37 +0800170 // Load ELF image when automatic ELF loading is enabled
171 if (IsAutoElfLoadingEnabled()) {
172 LoadElfFromCompilationUnit(curr_cunit_);
173 }
174
Logan Chien8b977d32012-02-21 19:14:55 +0800175 // Delete the compilation unit
Logan Chien7f767612012-03-01 18:54:49 +0800176 curr_cunit_ = NULL;
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800177}
178
179
Logan Chienf7015fd2012-03-18 01:19:37 +0800180void CompilerLLVM::EnableAutoElfLoading() {
181 MutexLock GUARD(compiler_lock_);
182
183 if (IsAutoElfLoadingEnabled()) {
184 // If there is an existing ELF loader, then do nothing.
185 // Because the existing ELF loader may have returned some code address
186 // already. If we replace the existing ELF loader with
187 // elf_loader_.reset(...), then it is possible to have some dangling
188 // pointer.
189 return;
190 }
191
192 // Create ELF loader and load the materialized CompilationUnit
193 elf_loader_.reset(new ElfLoader());
194
195 for (size_t i = 0; i < cunits_.size(); ++i) {
196 if (cunits_[i]->IsMaterialized()) {
197 LoadElfFromCompilationUnit(cunits_[i]);
198 }
199 }
200}
201
202
203void CompilerLLVM::LoadElfFromCompilationUnit(const CompilationUnit* cunit) {
204 compiler_lock_.AssertHeld();
205 DCHECK(cunit->IsMaterialized()) << cunit->GetElfIndex();
206
Logan Chien0c717dd2012-03-28 18:31:07 +0800207 if (!elf_loader_->LoadElfAt(cunit->GetElfIndex(),
208 cunit->GetElfImage(),
209 OatFile::kRelocAll)) {
Logan Chienf7015fd2012-03-18 01:19:37 +0800210 LOG(ERROR) << "Failed to load ELF from compilation unit "
211 << cunit->GetElfIndex();
212 }
213}
214
215
Logan Chien937105a2012-04-02 02:37:37 +0800216const void* CompilerLLVM::GetMethodCodeAddr(const CompiledMethod* cm) const {
217 return elf_loader_->GetMethodCodeAddr(cm->GetElfIndex(),
218 cm->GetElfFuncIndex());
Logan Chienf7015fd2012-03-18 01:19:37 +0800219}
220
221
222const Method::InvokeStub* CompilerLLVM::
Logan Chien937105a2012-04-02 02:37:37 +0800223GetMethodInvokeStubAddr(const CompiledInvokeStub* cm) const {
224 return elf_loader_->GetMethodInvokeStubAddr(cm->GetElfIndex(),
225 cm->GetElfFuncIndex());
Logan Chienf7015fd2012-03-18 01:19:37 +0800226}
227
228
Logan Chiendf576142012-03-20 17:36:32 +0800229std::vector<ElfImage> CompilerLLVM::GetElfImages() const {
230 std::vector<ElfImage> result;
231
232 for (size_t i = 0; i < cunits_.size(); ++i) {
233 result.push_back(cunits_[i]->GetElfImage());
234 }
235
236 return result;
237}
238
239
Logan Chien7f767612012-03-01 18:54:49 +0800240CompiledMethod* CompilerLLVM::
241CompileDexMethod(OatCompilationUnit* oat_compilation_unit) {
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800242 MutexLock GUARD(compiler_lock_);
243
Logan Chience119062012-03-02 11:57:34 +0800244 EnsureCompilationUnit();
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800245
Logan Chien8b977d32012-02-21 19:14:55 +0800246 UniquePtr<MethodCompiler> method_compiler(
Logan Chien7f767612012-03-01 18:54:49 +0800247 new MethodCompiler(curr_cunit_, compiler_, oat_compilation_unit));
Logan Chien8b977d32012-02-21 19:14:55 +0800248
Logan Chien7f767612012-03-01 18:54:49 +0800249 return method_compiler->Compile();
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800250}
Logan Chien83426162011-12-09 09:29:50 +0800251
252
Logan Chien7f767612012-03-01 18:54:49 +0800253CompiledMethod* CompilerLLVM::
254CompileNativeMethod(OatCompilationUnit* oat_compilation_unit) {
Logan Chien88894ee2012-02-13 16:42:22 +0800255 MutexLock GUARD(compiler_lock_);
256
Logan Chience119062012-03-02 11:57:34 +0800257 EnsureCompilationUnit();
Logan Chien88894ee2012-02-13 16:42:22 +0800258
Logan Chien8b977d32012-02-21 19:14:55 +0800259 UniquePtr<JniCompiler> jni_compiler(
Logan Chien7f767612012-03-01 18:54:49 +0800260 new JniCompiler(curr_cunit_, *compiler_, oat_compilation_unit));
Logan Chien8b977d32012-02-21 19:14:55 +0800261
Logan Chien7f767612012-03-01 18:54:49 +0800262 return jni_compiler->Compile();
Logan Chien88894ee2012-02-13 16:42:22 +0800263}
264
265
Logan Chienf04364f2012-02-10 12:01:39 +0800266CompiledInvokeStub* CompilerLLVM::CreateInvokeStub(bool is_static,
267 char const *shorty) {
Logan Chienf04364f2012-02-10 12:01:39 +0800268 MutexLock GUARD(compiler_lock_);
269
Logan Chience119062012-03-02 11:57:34 +0800270 EnsureCompilationUnit();
Logan Chienf04364f2012-02-10 12:01:39 +0800271
Logan Chien8b977d32012-02-21 19:14:55 +0800272 UniquePtr<UpcallCompiler> upcall_compiler(
Logan Chien7f767612012-03-01 18:54:49 +0800273 new UpcallCompiler(curr_cunit_, *compiler_));
Logan Chien8b977d32012-02-21 19:14:55 +0800274
Logan Chien7f767612012-03-01 18:54:49 +0800275 return upcall_compiler->CreateStub(is_static, shorty);
Logan Chienf04364f2012-02-10 12:01:39 +0800276}
277
Logan Chien83426162011-12-09 09:29:50 +0800278} // namespace compiler_llvm
279} // namespace art
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800280
Logan Chien106b2a02012-03-18 04:41:38 +0800281inline static art::compiler_llvm::CompilerLLVM* ContextOf(art::Compiler& compiler) {
282 void *compiler_context = compiler.GetCompilerContext();
283 CHECK(compiler_context != NULL);
284 return reinterpret_cast<art::compiler_llvm::CompilerLLVM*>(compiler_context);
285}
286
287inline static const art::compiler_llvm::CompilerLLVM* ContextOf(const art::Compiler& compiler) {
288 void *compiler_context = compiler.GetCompilerContext();
289 CHECK(compiler_context != NULL);
290 return reinterpret_cast<const art::compiler_llvm::CompilerLLVM*>(compiler_context);
291}
292
293extern "C" void ArtInitCompilerContext(art::Compiler& compiler) {
294 CHECK(compiler.GetCompilerContext() == NULL);
295
296 art::compiler_llvm::CompilerLLVM* compiler_llvm =
297 new art::compiler_llvm::CompilerLLVM(&compiler,
298 compiler.GetInstructionSet());
299
300 compiler.SetCompilerContext(compiler_llvm);
301}
302
Elliott Hughes3fa1b7e2012-03-13 17:06:22 -0700303extern "C" art::CompiledMethod* ArtCompileMethod(art::Compiler& compiler,
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800304 const art::DexFile::CodeItem* code_item,
305 uint32_t access_flags, uint32_t method_idx,
306 const art::ClassLoader* class_loader,
307 const art::DexFile& dex_file)
308{
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800309 art::ClassLinker *class_linker = art::Runtime::Current()->GetClassLinker();
310 art::DexCache *dex_cache = class_linker->FindDexCache(dex_file);
311
312 art::OatCompilationUnit oat_compilation_unit(
313 class_loader, class_linker, dex_file, *dex_cache, code_item,
314 method_idx, access_flags);
315
Logan Chien106b2a02012-03-18 04:41:38 +0800316 return ContextOf(compiler)->CompileDexMethod(&oat_compilation_unit);
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800317}
318
319extern "C" art::CompiledMethod* ArtJniCompileMethod(art::Compiler& compiler,
320 uint32_t access_flags, uint32_t method_idx,
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800321 const art::DexFile& dex_file) {
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800322 art::ClassLinker *class_linker = art::Runtime::Current()->GetClassLinker();
323 art::DexCache *dex_cache = class_linker->FindDexCache(dex_file);
324
325 art::OatCompilationUnit oat_compilation_unit(
Shih-wei Liaob1ab7df2012-03-29 13:53:46 -0700326 NULL, class_linker, dex_file, *dex_cache, NULL,
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800327 method_idx, access_flags);
328
Logan Chien106b2a02012-03-18 04:41:38 +0800329 art::compiler_llvm::CompilerLLVM* compiler_llvm = ContextOf(compiler);
Elliott Hughes6f4976c2012-03-13 21:19:01 -0700330 art::CompiledMethod* result = compiler_llvm->CompileNativeMethod(&oat_compilation_unit);
331 compiler_llvm->MaterializeIfThresholdReached();
Elliott Hughes13b835a2012-03-13 19:45:22 -0700332 return result;
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800333}
334
335extern "C" art::CompiledInvokeStub* ArtCreateInvokeStub(art::Compiler& compiler, bool is_static,
336 const char* shorty, uint32_t shorty_len) {
Logan Chien106b2a02012-03-18 04:41:38 +0800337 return ContextOf(compiler)->CreateInvokeStub(is_static, shorty);
338}
339
Logan Chien106b2a02012-03-18 04:41:38 +0800340extern "C" void compilerLLVMSetBitcodeFileName(art::Compiler& compiler,
341 std::string const& filename) {
342 ContextOf(compiler)->SetBitcodeFileName(filename);
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800343}
344
345extern "C" void compilerLLVMMaterializeRemainder(art::Compiler& compiler) {
Logan Chien106b2a02012-03-18 04:41:38 +0800346 ContextOf(compiler)->MaterializeRemainder();
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800347}
348
Logan Chienf7015fd2012-03-18 01:19:37 +0800349extern "C" void compilerLLVMEnableAutoElfLoading(art::Compiler& compiler) {
350 art::compiler_llvm::CompilerLLVM* compiler_llvm =
351 reinterpret_cast<art::compiler_llvm::CompilerLLVM*>(compiler.GetCompilerContext());
352 return compiler_llvm->EnableAutoElfLoading();
353}
354
355extern "C" const void* compilerLLVMGetMethodCodeAddr(const art::Compiler& compiler,
356 const art::CompiledMethod* cm,
Logan Chien937105a2012-04-02 02:37:37 +0800357 const art::Method*) {
Logan Chienf7015fd2012-03-18 01:19:37 +0800358 const art::compiler_llvm::CompilerLLVM* compiler_llvm =
359 reinterpret_cast<const art::compiler_llvm::CompilerLLVM*>(compiler.GetCompilerContext());
Logan Chien937105a2012-04-02 02:37:37 +0800360 return compiler_llvm->GetMethodCodeAddr(cm);
Logan Chienf7015fd2012-03-18 01:19:37 +0800361}
362
363extern "C" const art::Method::InvokeStub* compilerLLVMGetMethodInvokeStubAddr(const art::Compiler& compiler,
364 const art::CompiledInvokeStub* cm,
Logan Chien937105a2012-04-02 02:37:37 +0800365 const art::Method*) {
Logan Chienf7015fd2012-03-18 01:19:37 +0800366 const art::compiler_llvm::CompilerLLVM* compiler_llvm =
367 reinterpret_cast<const art::compiler_llvm::CompilerLLVM*>(compiler.GetCompilerContext());
Logan Chien937105a2012-04-02 02:37:37 +0800368 return compiler_llvm->GetMethodInvokeStubAddr(cm);
Logan Chienf7015fd2012-03-18 01:19:37 +0800369}
370
Logan Chiendf576142012-03-20 17:36:32 +0800371extern "C" std::vector<art::ElfImage> compilerLLVMGetElfImages(const art::Compiler& compiler) {
372 return ContextOf(compiler)->GetElfImages();
373}
374
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800375// Note: Using this function carefully!!! This is temporary solution, we will remove it.
376extern "C" art::MutexLock* compilerLLVMMutexLock(art::Compiler& compiler) {
Logan Chien106b2a02012-03-18 04:41:38 +0800377 return new art::MutexLock(ContextOf(compiler)->compiler_lock_);
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800378}
379
380extern "C" void compilerLLVMDispose(art::Compiler& compiler) {
Logan Chien106b2a02012-03-18 04:41:38 +0800381 delete ContextOf(compiler);
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800382}