Home | History | Annotate | Download | only in llvm 
      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 
     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 &registry = *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 
    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 
    118 CompilerLLVM::~CompilerLLVM() {
    119 }
    120 
    121 
    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::
    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::
    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 
    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 
    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 
    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 
    197 extern "C" void ArtUnInitCompilerContext(art::CompilerDriver& driver) {
    198   delete ContextOf(driver);
    199   driver.SetCompilerContext(NULL);
    200 }
    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 
    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 
    234 extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
    235                                                std::string const& filename) {
    236   ContextOf(driver)->SetBitcodeFileName(filename);
    237 }
    238