tools/llvmc/CompilerDriver.h

   1 //===- CompilerDriver.h - Compiler Driver -----------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Reid Spencer and is distributed under the
   6 // University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares the CompilerDriver class which implements the bulk of the
  11 // LLVM Compiler Driver program (llvmc).
  12 //
  13 //===------------------------------------------------------------------------===
  14 #ifndef LLVM_TOOLS_LLVMC_COMPILERDRIVER_H
  15 #define LLVM_TOOLS_LLVMC_COMPILERDRIVER_H
  16
  17 #include <string>
  18 #include <vector>
  19
  20 namespace llvm {
  21   /// This class provides the high level interface to the LLVM Compiler Driver.
  22   /// The driver's purpose is to make it easier for compiler writers and users
  23   /// of LLVM to utilize the compiler toolkits and LLVM toolset by learning only
  24   /// the interface of one program (llvmc).
  25   ///
  26   /// @see llvmc.cpp
  27   /// @brief The interface to the LLVM Compiler Driver.
  28   class CompilerDriver {
  29     /// @name Types
  30     /// @{
  31     public:
  32       /// @brief A vector of strings, commonly used
  33       typedef std::vector<std::string> StringVector;
  34
  35       /// @brief A table of strings, indexed typically by Phases
  36       typedef std::vector<StringVector> StringTable;
  37
  38       /// @brief The phases of processing that llvmc understands
  39       enum Phases {
  40         PREPROCESSING, ///< Source language combining, filtering, substitution
  41         TRANSLATION,   ///< Translate source -> LLVM bytecode/assembly
  42         OPTIMIZATION,  ///< Optimize translation result
  43         ASSEMBLY,      ///< Convert program to executable
  44         LINKING,       ///< Link bytecode and native code
  45         NUM_PHASES     ///< Always last!
  46       };
  47
  48       /// @brief The levels of optimization llvmc understands
  49       enum OptimizationLevels {
  50         OPT_FAST_COMPILE,         ///< Optimize to make >compile< go faster
  51         OPT_SIMPLE,               ///< Standard/simple optimizations
  52         OPT_AGGRESSIVE,           ///< Aggressive optimizations
  53         OPT_LINK_TIME,            ///< Aggressive + LinkTime optimizations
  54         OPT_AGGRESSIVE_LINK_TIME, ///< Make it go way fast!
  55         OPT_NONE                  ///< No optimizations. Keep this at the end!
  56       };
  57
  58       /// @brief Action specific flags
  59       enum ConfigurationFlags {
  60         REQUIRED_FLAG        = 0x0001, ///< Should the action always be run?
  61         GROKS_DASH_O_FLAG    = 0x0002, ///< Understands the -On options?
  62         PREPROCESSES_FLAG    = 0x0004, ///< Does this action preprocess?
  63         TRANSLATES_FLAG      = 0x0008, ///< Does this action translate?
  64         OPTIMIZES_FLAG       = 0x0010, ///< Does this action optimize?
  65         OUTPUT_IS_ASM_FLAG   = 0x0020, ///< Action produces .ll files?
  66         FLAGS_MASK           = 0x003F, ///< Union of all flags
  67       };
  68
  69       /// This type is the input list to the CompilerDriver. It provides
  70       /// a vector of filename/filetype pairs. The filetype is used to look up
  71       /// the configuration of the actions to be taken by the driver.
  72       /// @brief The Input Data to the execute method
  73       typedef std::vector<std::pair<std::string,std::string> > InputList;
  74
  75       /// This type is read from configuration files or otherwise provided to
  76       /// the CompilerDriver through a "ConfigDataProvider". It serves as both
  77       /// the template of what to do and the actual Action to be executed.
  78       /// @brief A structure to hold the action data for a given source
  79       /// language.
  80       struct Action {
  81         Action() : flags(0) {}
  82         std::string program;   ///< The program to execve
  83         StringVector args;     ///< Arguments to the program
  84         unsigned flags;        ///< Action specific flags
  85         void set(unsigned fl ) { flags |= fl; }
  86         void clear(unsigned fl) { flags &= (FLAGS_MASK ^ fl); }
  87         bool isSet(unsigned fl) { return (flags&fl) != 0; }
  88       };
  89
  90       struct ConfigData {
  91         ConfigData();
  92         std::string langName;   ///< The name of the source language
  93         StringTable opts;       ///< The o10n options for each level
  94         Action PreProcessor;    ///< PreProcessor command line
  95         Action Translator;      ///< Translator command line
  96         Action Optimizer;       ///< Optimizer command line
  97         Action Assembler;       ///< Assembler command line
  98         Action Linker;          ///< Linker command line
  99       };
 100
 101       /// This pure virtual interface class defines the interface between the
 102       /// CompilerDriver and other software that provides ConfigData objects to
 103       /// it. The CompilerDriver must be configured to use an object of this
 104       /// type so it can obtain the configuration data.
 105       /// @see setConfigDataProvider
 106       /// @brief Configuration Data Provider interface
 107       class ConfigDataProvider {
 108       public:
 109         virtual ConfigData* ProvideConfigData(const std::string& filetype) = 0;
 110         virtual void setConfigDir(const std::string& dirName) = 0;
 111       };
 112
 113     /// @}
 114     /// @name Constructors
 115     /// @{
 116     public:
 117       CompilerDriver(ConfigDataProvider& cdp );
 118       virtual ~CompilerDriver();
 119
 120     /// @}
 121     /// @name Methods
 122     /// @{
 123     public:
 124       /// @brief Handle an error
 125       virtual void error(const std::string& errmsg);
 126
 127       /// @brief Execute the actions requested for the given input list.
 128       virtual int execute(const InputList& list, const std::string& output);
 129
 130     /// @}
 131     /// @name Mutators
 132     /// @{
 133     public:
 134       /// @brief Set the final phase at which compilation terminates
 135       void setFinalPhase( Phases phase ) { finalPhase = phase; }
 136
 137       /// @brief Set the optimization level for the compilation
 138       void setOptimization( OptimizationLevels level ) { optLevel = level; }
 139
 140       /// @brief Prevent the CompilerDriver from taking any actions
 141       void setDryRun( bool TF ) { isDryRun = TF; }
 142
 143       /// @brief Cause the CompilerDriver to print to stderr all the
 144       /// actions it is taking.
 145       void setVerbose( bool TF ) { isVerbose = TF; }
 146
 147       /// @brief Cause the CompilerDriver to print to stderr very verbose
 148       /// information that might be useful in debugging the driver's actions
 149       void setDebug( bool TF ) { isDebug = TF; }
 150
 151       /// @brief Cause the CompilerDriver to print to stderr the
 152       /// execution time of each action taken.
 153       void setTimeActions( bool TF ) { timeActions = TF; }
 154
 155       /// @brief Cause the CompilerDriver to print timings for each pass.
 156       void setTimePasses( bool TF ) { timePasses = TF; }
 157
 158       /// @brief Cause the CompilerDriver to show statistics gathered
 159       void setShowStats( bool TF ) { showStats = TF; }
 160
 161       /// @brief Indicate that native code is to be generated instead
 162       /// of LLVM bytecode.
 163       void setEmitNativeCode( bool TF ) { emitNativeCode = TF; }
 164
 165       /// @brief Indicate that raw, unoptimized code is to be generated.
 166       void setEmitRawCode(bool TF ) { emitRawCode = TF; }
 167
 168       void setKeepTemporaries(bool TF) { keepTemps = TF; }
 169
 170       /// @brief Set the output machine name.
 171       void setOutputMachine( const std::string& machineName ) {
 172         machine = machineName;
 173       }
 174
 175       /// @brief Set Preprocessor specific options
 176       void setPhaseArgs(Phases phase, const std::vector<std::string>& opts) {
 177         assert(phase <= LINKING && phase >= PREPROCESSING);
 178         AdditionalArgs[phase] = opts;
 179       }
 180
 181       /// @brief Set Library Paths
 182       void setLibraryPaths(const std::vector<std::string>& paths) {
 183         LibraryPaths = paths;
 184       }
 185
 186       /// @brief Set the list of library paths to be searched for
 187       /// libraries.
 188       void addLibraryPath( const std::string& libPath ) {
 189         LibraryPaths.push_back(libPath);
 190       }
 191
 192     /// @}
 193     /// @name Functions
 194     /// @{
 195     private:
 196       Action* GetAction(ConfigData* cd, const std::string& input,
 197                        const std::string& output, Phases phase );
 198       bool DoAction(Action* a);
 199
 200     /// @}
 201     /// @name Data
 202     /// @{
 203     private:
 204       ConfigDataProvider* cdp;      ///< Where we get configuration data from
 205       Phases finalPhase;            ///< The final phase of compilation
 206       OptimizationLevels optLevel;  ///< The optimization level to apply
 207       bool isDryRun;                ///< Prevent actions ?
 208       bool isVerbose;               ///< Print actions?
 209       bool isDebug;                 ///< Print lotsa debug info?
 210       bool timeActions;             ///< Time the actions executed ?
 211       bool timePasses;              ///< Time each pass and print timing ?
 212       bool showStats;               ///< Show gathered statistics ?
 213       bool emitRawCode;             ///< Emit Raw (unoptimized) code?
 214       bool emitNativeCode;          ///< Emit native code instead of bytecode?
 215       bool keepTemps;               ///< Keep temporary files?
 216       std::string machine;          ///< Target machine name
 217       StringVector LibraryPaths;    ///< -L options
 218       StringTable  AdditionalArgs;  ///< The -Txyz options
 219       std::string TempDir;          ///< Name of the temporary directory.
 220
 221     /// @}
 222
 223   };
 224 }
 225
 226 // vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
 227 #endif