Home | History | Annotate | Download | only in bcc 
      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 namespace llvm {
     21 
     22 class raw_ostream;
     23 class PassManager;
     24 class DataLayout;
     25 class TargetMachine;
     26 
     27 } // end namespace llvm
     28 
     29 namespace bcc {
     30 
     31 class CompilerConfig;
     32 class OutputFile;
     33 class Script;
     34 
     35 //===----------------------------------------------------------------------===//
     36 // Design of Compiler
     37 //===----------------------------------------------------------------------===//
     38 // 1. A compiler instance can be constructed provided an "initial config."
     39 // 2. A compiler can later be re-configured using config().
     40 // 3. Once config() is invoked, it'll re-create TargetMachine instance (i.e.,
     41 //    mTarget) according to the configuration supplied. TargetMachine instance
     42 //    is *shared* across the different calls to compile() before the next call
     43 //    to config().
     44 // 4. Once a compiler instance is created, you can use the compile() service
     45 //    to compile the file over and over again. Each call uses TargetMachine
     46 //    instance to construct the compilation passes.
     47 class Compiler {
     48 public:
     49   enum ErrorCode {
     50     kSuccess,
     51 
     52     kInvalidConfigNoTarget,
     53     kErrCreateTargetMachine,
     54     kErrSwitchTargetMachine,
     55     kErrNoTargetMachine,
     56     kErrDataLayoutNoMemory,
     57     kErrMaterialization,
     58     kErrInvalidOutputFileState,
     59     kErrPrepareOutput,
     60     kPrepareCodeGenPass,
     61 
     62     kErrHookBeforeAddLTOPasses,
     63     kErrHookAfterAddLTOPasses,
     64     kErrHookAfterExecuteLTOPasses,
     65 
     66     kErrHookBeforeAddCodeGenPasses,
     67     kErrHookAfterAddCodeGenPasses,
     68     kErrHookBeforeExecuteCodeGenPasses,
     69     kErrHookAfterExecuteCodeGenPasses,
     70 
     71     kErrInvalidSource
     72   };
     73 
     74   static const char *GetErrorString(enum ErrorCode pErrCode);
     75 
     76 private:
     77   llvm::TargetMachine *mTarget;
     78   // LTO is enabled by default.
     79   bool mEnableLTO;
     80 
     81   enum ErrorCode runLTO(Script &pScript);
     82   enum ErrorCode runCodeGen(Script &pScript, llvm::raw_ostream &pResult);
     83 
     84 public:
     85   Compiler();
     86   Compiler(const CompilerConfig &pConfig);
     87 
     88   enum ErrorCode config(const CompilerConfig &pConfig);
     89 
     90   // Compile a script and output the result to a LLVM stream.
     91   //
     92   // @param IRStream If not NULL, the LLVM-IR that is fed to code generation
     93   //                 will be written to IRStream.
     94   enum ErrorCode compile(Script &pScript, llvm::raw_ostream &pResult,
     95                          llvm::raw_ostream *IRStream);
     96 
     97   // Compile a script and output the result to a file.
     98   enum ErrorCode compile(Script &pScript, OutputFile &pResult,
     99                          llvm::raw_ostream *IRStream = 0);
    100 
    101   const llvm::TargetMachine& getTargetMachine() const
    102   { return *mTarget; }
    103 
    104   void enableLTO(bool pEnable = true)
    105   { mEnableLTO = pEnable; }
    106 
    107   virtual ~Compiler();
    108 
    109 protected:
    110   //===--------------------------------------------------------------------===//
    111   // Plugin callbacks for sub-class.
    112   //===--------------------------------------------------------------------===//
    113   // Called before adding first pass to code-generation passes.
    114   virtual bool beforeAddLTOPasses(Script &pScript, llvm::PassManager &pPM)
    115   { return true; }
    116 
    117   // Called after adding last pass to code-generation passes.
    118   virtual bool afterAddLTOPasses(Script &pScript, llvm::PassManager &pPM)
    119   { return true; }
    120 
    121   // Called before executing code-generation passes.
    122   virtual bool beforeExecuteLTOPasses(Script &pScript,
    123                                           llvm::PassManager &pPM)
    124   { return true; }
    125 
    126   // Called after executing code-generation passes.
    127   virtual bool afterExecuteLTOPasses(Script &pScript)
    128   { return true; }
    129 
    130   // Called before adding first pass to code-generation passes.
    131   virtual bool beforeAddCodeGenPasses(Script &pScript, llvm::PassManager &pPM)
    132   { return true; }
    133 
    134   // Called after adding last pass to code-generation passes.
    135   virtual bool afterAddCodeGenPasses(Script &pScript, llvm::PassManager &pPM)
    136   { return true; }
    137 
    138   // Called before executing code-generation passes.
    139   virtual bool beforeExecuteCodeGenPasses(Script &pScript,
    140                                           llvm::PassManager &pPM)
    141   { return true; }
    142 
    143   // Called after executing code-generation passes.
    144   virtual bool afterExecuteCodeGenPasses(Script &pScript)
    145   { return true; }
    146 };
    147 
    148 } // end namespace bcc
    149 
    150 #endif // BCC_COMPILER_H
    151