1 /*
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
19 #include "backend_options.h"
20 #include "base/stl_util.h"
21 #include "class_linker.h"
22 #include "compiled_method.h"
23 #include "driver/compiler_driver.h"
24 #include "driver/dex_compilation_unit.h"
25 #include "globals.h"
26 #include "ir_builder.h"
27 #include "jni/portable/jni_compiler.h"
28 #include "llvm_compilation_unit.h"
29 #include "utils_llvm.h"
30 #include "verifier/method_verifier.h"
31
32 #include <llvm/LinkAllPasses.h>
33 #include <llvm/Support/ManagedStatic.h>
34 #include <llvm/Support/TargetSelect.h>
35 #include <llvm/Support/Threading.h>
36
37 namespace art {
38 void CompileOneMethod(CompilerDriver& driver,
39 const CompilerBackend compilerBackend,
40 const DexFile::CodeItem* code_item,
41 uint32_t access_flags, InvokeType invoke_type,
42 uint16_t class_def_idx, uint32_t method_idx, jobject class_loader,
43 const DexFile& dex_file,
44 llvm::LlvmCompilationUnit* llvm_info);
45 }
46
47 namespace llvm {
48 extern bool TimePassesIsEnabled;
49 }
50
51 namespace {
52
53 pthread_once_t llvm_initialized = PTHREAD_ONCE_INIT;
54
InitializeLLVM()55 void InitializeLLVM() {
56 // Initialize LLVM internal data structure for multithreading
57 llvm::llvm_start_multithreaded();
58
59 // NOTE: Uncomment following line to show the time consumption of LLVM passes
60 // llvm::TimePassesIsEnabled = true;
61
62 // Initialize LLVM target-specific options.
63 art::llvm::InitialBackendOptions();
64
65 // Initialize LLVM target, MC subsystem, asm printer, and asm parser.
66 if (art::kIsTargetBuild) {
67 // Don't initialize all targets on device. Just initialize the device's native target
68 llvm::InitializeNativeTarget();
69 llvm::InitializeNativeTargetAsmPrinter();
70 llvm::InitializeNativeTargetAsmParser();
71 } else {
72 llvm::InitializeAllTargets();
73 llvm::InitializeAllTargetMCs();
74 llvm::InitializeAllAsmPrinters();
75 llvm::InitializeAllAsmParsers();
76 }
77
78 // Initialize LLVM optimization passes
79 llvm::PassRegistry ®istry = *llvm::PassRegistry::getPassRegistry();
80
81 llvm::initializeCore(registry);
82 llvm::initializeScalarOpts(registry);
83 llvm::initializeIPO(registry);
84 llvm::initializeAnalysis(registry);
85 llvm::initializeIPA(registry);
86 llvm::initializeTransformUtils(registry);
87 llvm::initializeInstCombine(registry);
88 llvm::initializeInstrumentation(registry);
89 llvm::initializeTarget(registry);
90 }
91
92 // The Guard to Shutdown LLVM
93 // llvm::llvm_shutdown_obj llvm_guard;
94 // TODO: We are commenting out this line because this will cause SEGV from
95 // time to time.
96 // Two reasons: (1) the order of the destruction of static objects, or
97 // (2) dlopen/dlclose side-effect on static objects.
98
99 } // anonymous namespace
100
101
102 namespace art {
103 namespace llvm {
104
105
106 ::llvm::Module* makeLLVMModuleContents(::llvm::Module* module);
107
108
CompilerLLVM(CompilerDriver * driver,InstructionSet insn_set)109 CompilerLLVM::CompilerLLVM(CompilerDriver* driver, InstructionSet insn_set)
110 : compiler_driver_(driver), insn_set_(insn_set),
111 next_cunit_id_lock_("compilation unit id lock"), next_cunit_id_(1) {
112
113 // Initialize LLVM libraries
114 pthread_once(&llvm_initialized, InitializeLLVM);
115 }
116
117
~CompilerLLVM()118 CompilerLLVM::~CompilerLLVM() {
119 }
120
121
AllocateCompilationUnit()122 LlvmCompilationUnit* CompilerLLVM::AllocateCompilationUnit() {
123 MutexLock GUARD(Thread::Current(), next_cunit_id_lock_);
124 LlvmCompilationUnit* cunit = new LlvmCompilationUnit(this, next_cunit_id_++);
125 if (!bitcode_filename_.empty()) {
126 cunit->SetBitcodeFileName(StringPrintf("%s-%zu",
127 bitcode_filename_.c_str(),
128 cunit->GetCompilationUnitId()));
129 }
130 return cunit;
131 }
132
133
134 CompiledMethod* CompilerLLVM::
CompileDexMethod(DexCompilationUnit * dex_compilation_unit,InvokeType invoke_type)135 CompileDexMethod(DexCompilationUnit* dex_compilation_unit, InvokeType invoke_type) {
136 UniquePtr<LlvmCompilationUnit> cunit(AllocateCompilationUnit());
137
138 cunit->SetDexCompilationUnit(dex_compilation_unit);
139 cunit->SetCompilerDriver(compiler_driver_);
140 // TODO: consolidate ArtCompileMethods
141 CompileOneMethod(*compiler_driver_,
142 kPortable,
143 dex_compilation_unit->GetCodeItem(),
144 dex_compilation_unit->GetAccessFlags(),
145 invoke_type,
146 dex_compilation_unit->GetClassDefIndex(),
147 dex_compilation_unit->GetDexMethodIndex(),
148 dex_compilation_unit->GetClassLoader(),
149 *dex_compilation_unit->GetDexFile(),
150 cunit.get());
151
152 cunit->Materialize();
153
154 MethodReference mref(dex_compilation_unit->GetDexFile(),
155 dex_compilation_unit->GetDexMethodIndex());
156 return new CompiledMethod(*compiler_driver_, compiler_driver_->GetInstructionSet(),
157 cunit->GetElfObject(), *verifier::MethodVerifier::GetDexGcMap(mref),
158 cunit->GetDexCompilationUnit()->GetSymbol());
159 }
160
161
162 CompiledMethod* CompilerLLVM::
CompileNativeMethod(DexCompilationUnit * dex_compilation_unit)163 CompileNativeMethod(DexCompilationUnit* dex_compilation_unit) {
164 UniquePtr<LlvmCompilationUnit> cunit(AllocateCompilationUnit());
165
166 UniquePtr<JniCompiler> jni_compiler(
167 new JniCompiler(cunit.get(), *compiler_driver_, dex_compilation_unit));
168
169 return jni_compiler->Compile();
170 }
171
172
173 } // namespace llvm
174 } // namespace art
175
ContextOf(art::CompilerDriver & driver)176 inline static art::llvm::CompilerLLVM* ContextOf(art::CompilerDriver& driver) {
177 void *compiler_context = driver.GetCompilerContext();
178 CHECK(compiler_context != NULL);
179 return reinterpret_cast<art::llvm::CompilerLLVM*>(compiler_context);
180 }
181
ContextOf(const art::CompilerDriver & driver)182 inline static const art::llvm::CompilerLLVM* ContextOf(const art::CompilerDriver& driver) {
183 void *compiler_context = driver.GetCompilerContext();
184 CHECK(compiler_context != NULL);
185 return reinterpret_cast<const art::llvm::CompilerLLVM*>(compiler_context);
186 }
187
ArtInitCompilerContext(art::CompilerDriver & driver)188 extern "C" void ArtInitCompilerContext(art::CompilerDriver& driver) {
189 CHECK(driver.GetCompilerContext() == NULL);
190
191 art::llvm::CompilerLLVM* compiler_llvm = new art::llvm::CompilerLLVM(&driver,
192 driver.GetInstructionSet());
193
194 driver.SetCompilerContext(compiler_llvm);
195 }
196
ArtUnInitCompilerContext(art::CompilerDriver & driver)197 extern "C" void ArtUnInitCompilerContext(art::CompilerDriver& driver) {
198 delete ContextOf(driver);
199 driver.SetCompilerContext(NULL);
200 }
ArtCompileMethod(art::CompilerDriver & driver,const art::DexFile::CodeItem * code_item,uint32_t access_flags,art::InvokeType invoke_type,uint16_t class_def_idx,uint32_t method_idx,jobject class_loader,const art::DexFile & dex_file)201 extern "C" art::CompiledMethod* ArtCompileMethod(art::CompilerDriver& driver,
202 const art::DexFile::CodeItem* code_item,
203 uint32_t access_flags,
204 art::InvokeType invoke_type,
205 uint16_t class_def_idx,
206 uint32_t method_idx,
207 jobject class_loader,
208 const art::DexFile& dex_file) {
209 UNUSED(class_def_idx); // TODO: this is used with Compiler::RequiresConstructorBarrier.
210 art::ClassLinker *class_linker = art::Runtime::Current()->GetClassLinker();
211
212 art::DexCompilationUnit dex_compilation_unit(
213 NULL, class_loader, class_linker, dex_file, code_item,
214 class_def_idx, method_idx, access_flags);
215 art::llvm::CompilerLLVM* compiler_llvm = ContextOf(driver);
216 art::CompiledMethod* result = compiler_llvm->CompileDexMethod(&dex_compilation_unit, invoke_type);
217 return result;
218 }
219
ArtLLVMJniCompileMethod(art::CompilerDriver & driver,uint32_t access_flags,uint32_t method_idx,const art::DexFile & dex_file)220 extern "C" art::CompiledMethod* ArtLLVMJniCompileMethod(art::CompilerDriver& driver,
221 uint32_t access_flags, uint32_t method_idx,
222 const art::DexFile& dex_file) {
223 art::ClassLinker *class_linker = art::Runtime::Current()->GetClassLinker();
224
225 art::DexCompilationUnit dex_compilation_unit(
226 NULL, NULL, class_linker, dex_file, NULL,
227 0, method_idx, access_flags);
228
229 art::llvm::CompilerLLVM* compiler_llvm = ContextOf(driver);
230 art::CompiledMethod* result = compiler_llvm->CompileNativeMethod(&dex_compilation_unit);
231 return result;
232 }
233
compilerLLVMSetBitcodeFileName(art::CompilerDriver & driver,std::string const & filename)234 extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
235 std::string const& filename) {
236 ContextOf(driver)->SetBitcodeFileName(filename);
237 }
238