Home | History | Annotate | Download | only in ExecutionEngine 
      1 /*
      2  * Copyright 2010-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 #ifndef BCC_COMPILER_H
     18 #define BCC_COMPILER_H
     19 
     20 #include <bcc/bcc.h>
     21 
     22 #include <Config.h>
     23 
     24 #include "librsloader.h"
     25 
     26 #include "llvm/ADT/OwningPtr.h"
     27 #include "llvm/ADT/StringRef.h"
     28 #include "llvm/ADT/SmallVector.h"
     29 #include "llvm/ADT/Triple.h"
     30 #include "llvm/Target/TargetMachine.h"
     31 
     32 #include <stddef.h>
     33 
     34 #include <list>
     35 #include <string>
     36 #include <vector>
     37 #include <utility>
     38 
     39 
     40 namespace llvm {
     41   class Module;
     42   class NamedMDNode;
     43   class TargetData;
     44 }
     45 
     46 
     47 namespace bcc {
     48   class ScriptCompiled;
     49   struct CompilerOption;
     50 
     51   class Compiler {
     52   private:
     53     //////////////////////////////////////////////////////////////////////////
     54     // The variable section below (e.g., Triple, CodeGenOptLevel)
     55     // is initialized in GlobalInitialization()
     56     //
     57     static bool GlobalInitialized;
     58 
     59     // If given, this will be the name of the target triple to compile for.
     60     // If not given, the initial values defined in this file will be used.
     61     static std::string Triple;
     62     static llvm::Triple::ArchType ArchType;
     63 
     64     static llvm::CodeGenOpt::Level CodeGenOptLevel;
     65 
     66     // End of section of GlobalInitializing variables
     67     /////////////////////////////////////////////////////////////////////////
     68     // If given, the name of the target CPU to generate code for.
     69     static std::string CPU;
     70 
     71     // The list of target specific features to enable or disable -- this should
     72     // be a list of strings starting with '+' (enable) or '-' (disable).
     73     static std::vector<std::string> Features;
     74 
     75     static void LLVMErrorHandler(void *UserData, const std::string &Message);
     76 
     77     friend class CodeEmitter;
     78     friend class CodeMemoryManager;
     79 
     80   private:
     81     ScriptCompiled *mpResult;
     82 
     83     std::string mError;
     84 
     85     // Compilation buffer for MC
     86     llvm::SmallVector<char, 1024> mEmittedELFExecutable;
     87 
     88     // Loaded and relocated executable
     89     RSExecRef mRSExecutable;
     90 
     91     BCCSymbolLookupFn mpSymbolLookupFn;
     92     void *mpSymbolLookupContext;
     93 
     94     llvm::Module *mModule;
     95 
     96     bool mHasLinked;
     97 
     98   public:
     99     Compiler(ScriptCompiled *result);
    100 
    101     static void GlobalInitialization();
    102 
    103     static std::string const &getTargetTriple() {
    104       return Triple;
    105     }
    106 
    107     static llvm::Triple::ArchType getTargetArchType() {
    108       return ArchType;
    109     }
    110 
    111     void registerSymbolCallback(BCCSymbolLookupFn pFn, void *pContext) {
    112       mpSymbolLookupFn = pFn;
    113       mpSymbolLookupContext = pContext;
    114     }
    115 
    116     void *getSymbolAddress(char const *name);
    117 
    118     const llvm::SmallVector<char, 1024> &getELF() const {
    119       return mEmittedELFExecutable;
    120     }
    121 
    122     int readModule(llvm::Module *module) {
    123       mModule = module;
    124       return hasError();
    125     }
    126 
    127     int linkModule(llvm::Module *module);
    128 
    129     int compile(const CompilerOption &option);
    130 
    131     char const *getErrorMessage() {
    132       return mError.c_str();
    133     }
    134 
    135     const llvm::Module *getModule() const {
    136       return mModule;
    137     }
    138 
    139     ~Compiler();
    140 
    141   private:
    142 
    143     int runCodeGen(llvm::TargetData *TD, llvm::TargetMachine *TM,
    144                    llvm::NamedMDNode const *ExportVarMetadata,
    145                    llvm::NamedMDNode const *ExportFuncMetadata);
    146 
    147     int runMCCodeGen(llvm::TargetData *TD, llvm::TargetMachine *TM);
    148 
    149     static void *resolveSymbolAdapter(void *context, char const *name);
    150 
    151     int runInternalPasses(std::vector<std::string>& Names,
    152                           std::vector<uint32_t>& Signatures);
    153 
    154     int runLTO(llvm::TargetData *TD,
    155                std::vector<const char*>& ExportSymbols,
    156                llvm::CodeGenOpt::Level OptimizationLevel);
    157 
    158     bool hasError() const {
    159       return !mError.empty();
    160     }
    161 
    162     void setError(const char *Error) {
    163       mError.assign(Error);  // Copying
    164     }
    165 
    166     void setError(const std::string &Error) {
    167       mError = Error;
    168     }
    169 
    170   };  // End of class Compiler
    171 
    172 } // namespace bcc
    173 
    174 #endif // BCC_COMPILER_H
    175