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 #include "llvm/System/Program.h"
  20
  21 namespace llvm {
  22   /// This class provides the high level interface to the LLVM Compiler Driver.
  23   /// The driver's purpose is to make it easier for compiler writers and users
  24   /// of LLVM to utilize the compiler toolkits and LLVM toolset by learning only
  25   /// the interface of one program (llvmc).
  26   ///
  27   /// @see llvmc.cpp
  28   /// @brief The interface to the LLVM Compiler Driver.
  29   class CompilerDriver {
  30     /// @name Types
  31     /// @{
  32     public:
  33       /// @brief A vector of strings, used for argument lists
  34       typedef std::vector<std::string> StringVector;
  35
  36       /// @brief A vector of sys::Path, used for path lists
  37       typedef std::vector<sys::Path> PathVector;
  38
  39       /// @brief A table of strings, indexed typically by Phases
  40       typedef std::vector<StringVector> StringTable;
  41
  42       /// @brief The phases of processing that llvmc understands
  43       enum Phases {
  44         PREPROCESSING, ///< Source language combining, filtering, substitution
  45         TRANSLATION,   ///< Translate source -> LLVM bytecode/assembly
  46         OPTIMIZATION,  ///< Optimize translation result
  47         ASSEMBLY,      ///< Convert program to executable
  48         LINKING,       ///< Link bytecode and native code
  49         NUM_PHASES     ///< Always last!
  50       };
  51
  52       /// @brief The levels of optimization llvmc understands
  53       enum OptimizationLevels {
  54         OPT_FAST_COMPILE,         ///< Optimize to make >compile< go faster
  55         OPT_SIMPLE,               ///< Standard/simple optimizations
  56         OPT_AGGRESSIVE,           ///< Aggressive optimizations
  57         OPT_LINK_TIME,            ///< Aggressive + LinkTime optimizations
  58         OPT_AGGRESSIVE_LINK_TIME, ///< Make it go way fast!
  59         OPT_NONE                  ///< No optimizations. Keep this at the end!
  60       };
  61
  62       /// @brief Action specific flags
  63       enum ConfigurationFlags {
  64         REQUIRED_FLAG        = 0x0001, ///< Should the action always be run?
  65         PREPROCESSES_FLAG    = 0x0002, ///< Does this action preprocess?
  66         TRANSLATES_FLAG      = 0x0004, ///< Does this action translate?
  67         OUTPUT_IS_ASM_FLAG   = 0x0008, ///< Action produces .ll files?
  68         FLAGS_MASK           = 0x000F, ///< Union of all flags
  69       };
  70
  71       /// This type is the input list to the CompilerDriver. It provides
  72       /// a vector of pathname/filetype pairs. The filetype is used to look up
  73       /// the configuration of the actions to be taken by the driver.
  74       /// @brief The Input Data to the execute method
  75       typedef std::vector<std::pair<sys::Path,std::string> > InputList;
  76
  77       /// This type is read from configuration files or otherwise provided to
  78       /// the CompilerDriver through a "ConfigDataProvider". It serves as both
  79       /// the template of what to do and the actual Action to be executed.
  80       /// @brief A structure to hold the action data for a given source
  81       /// language.
  82       struct Action {
  83         Action() : flags(0) {}
  84         sys::Path program; ///< The program to execve
  85         StringVector args; ///< Arguments to the program
  86         unsigned flags;    ///< Action specific flags
  87         void set(unsigned fl ) { flags |= fl; }
  88         void clear(unsigned fl) { flags &= (FLAGS_MASK ^ fl); }
  89         bool isSet(unsigned fl) { return (flags&fl) != 0; }
  90       };
  91
  92       struct ConfigData {
  93         ConfigData();
  94         std::string version;    ///< The version number.
  95         std::string langName;   ///< The name of the source language
  96         StringTable opts;       ///< The o10n options for each level
  97         StringVector libpaths;  ///< The library paths
  98         Action PreProcessor;    ///< PreProcessor command line
  99         Action Translator;      ///< Translator command line
 100         Action Optimizer;       ///< Optimizer command line
 101         Action Assembler;       ///< Assembler command line
 102         Action Linker;          ///< Linker command line
 103       };
 104
 105       /// This pure virtual interface class defines the interface between the
 106       /// CompilerDriver and other software that provides ConfigData objects to
 107       /// it. The CompilerDriver must be configured to use an object of this
 108       /// type so it can obtain the configuration data.
 109       /// @see setConfigDataProvider
 110       /// @brief Configuration Data Provider interface
 111       class ConfigDataProvider {
 112       public:
 113         virtual ~ConfigDataProvider();
 114         virtual ConfigData* ProvideConfigData(const std::string& filetype) = 0;
 115         virtual void setConfigDir(const sys::Path& dirName) = 0;
 116       };
 117
 118       /// These flags control various actions of the compiler driver. They are
 119       /// used by adding the needed flag values together and passing them to the
 120       /// compiler driver's setDriverFlags method.
 121       /// @see setDriverFlags
 122       /// @brief Driver specific flags
 123       enum DriverFlags {
 124         DRY_RUN_FLAG         = 0x0001, ///< Do everything but execute actions
 125         VERBOSE_FLAG         = 0x0002, ///< Print each action
 126         DEBUG_FLAG           = 0x0004, ///< Print debug information
 127         TIME_PASSES_FLAG     = 0x0008, ///< Time the passes as they execute
 128         TIME_ACTIONS_FLAG    = 0x0010, ///< Time the actions as they execute
 129         SHOW_STATS_FLAG      = 0x0020, ///< Show pass statistics
 130         EMIT_NATIVE_FLAG     = 0x0040, ///< Emit native code instead of bc
 131         EMIT_RAW_FLAG        = 0x0080, ///< Emit raw, unoptimized bytecode
 132         KEEP_TEMPS_FLAG      = 0x0100, ///< Don't delete temporary files
 133         STRIP_OUTPUT_FLAG    = 0x0200, ///< Strip symbols from linked output
 134         DRIVER_FLAGS_MASK    = 0x03FF, ///< Union of the above flags
 135       };
 136
 137     /// @}
 138     /// @name Constructors
 139     /// @{
 140     public:
 141       /// @brief Static Constructor
 142       static CompilerDriver* Get(ConfigDataProvider& CDP);
 143
 144       /// @brief Virtual destructor
 145       virtual ~CompilerDriver();
 146
 147     /// @}
 148     /// @name Methods
 149     /// @{
 150     public:
 151       /// @brief Execute the actions requested for the given input list.
 152       virtual int execute(const InputList& list, const sys::Path& output) = 0;
 153
 154       /// @brief Set the final phase at which compilation terminates
 155       virtual void setFinalPhase(Phases phase) = 0;
 156
 157       /// @brief Set the optimization level for the compilation
 158       virtual void setOptimization(OptimizationLevels level) = 0;
 159
 160       /// @brief Set the driver flags.
 161       virtual void setDriverFlags(unsigned flags) = 0;
 162
 163       /// @brief Set the output machine name.
 164       virtual void setOutputMachine(const std::string& machineName) = 0;
 165
 166       /// @brief Set the options for a given phase.
 167       virtual void setPhaseArgs(Phases phase, const StringVector& opts) = 0;
 168
 169       /// @brief Set Library Paths
 170       virtual void setIncludePaths(const StringVector& paths) = 0;
 171
 172       /// @brief Set Library Paths
 173       virtual void setSymbolDefines(const StringVector& paths) = 0;
 174
 175       /// @brief Set Library Paths
 176       virtual void setLibraryPaths(const StringVector& paths) = 0;
 177
 178       /// @brief Add a path to the list of library paths
 179       virtual void addLibraryPath( const sys::Path& libPath )  = 0;
 180
 181       /// @brief Add a path to the list of paths in which to find tools
 182       virtual void addToolPath( const sys::Path& toolPath) = 0;
 183
 184       /// @brief Set the list of -f options to be passed through
 185       virtual void setfPassThrough(const StringVector& fOpts) = 0;
 186
 187       /// @brief Set the list of -M options to be passed through
 188       virtual void setMPassThrough(const StringVector& fOpts) = 0;
 189
 190       /// @brief Set the list of -W options to be passed through
 191       virtual void setWPassThrough(const StringVector& fOpts) = 0;
 192
 193       /// @brief Determine where a linkage file is located in the file system
 194       virtual sys::Path GetPathForLinkageItem(
 195         const std::string& link_item, ///< Item to be sought
 196         bool native = false           ///< Looking for native?
 197       ) = 0;
 198
 199     /// @}
 200   };
 201 }
 202
 203 // vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
 204 #endif