tools/llvmc/llvmc.cpp

   1 //===--- llvmc.cpp - The LLVM 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 tool provides a single point of access to the LLVM compilation tools.
  11 //  It has many options. To discover the options supported please refer to the
  12 //  tools' manual page (docs/CommandGuide/html/llvmc.html) or run the tool with
  13 //  the --help option.
  14 //
  15 //===------------------------------------------------------------------------===
  16
  17 #include "CompilerDriver.h"
  18 #include "ConfigData.h"
  19 #include "llvm/System/Signals.h"
  20 #include "Support/CommandLine.h"
  21 #include <iostream>
  22
  23 using namespace llvm;
  24
  25 namespace {
  26 //===------------------------------------------------------------------------===
  27 //===          PHASE OPTIONS
  28 //===------------------------------------------------------------------------===
  29 static cl::opt<CompilerDriver::Phases> FinalPhase(
  30   cl::desc("Choose final phase of compilation:"),
  31   cl::init(CompilerDriver::LINKING),
  32   cl::values(
  33     clEnumValN(CompilerDriver::PREPROCESSING,"E",
  34       "Stop compilation after pre-processing phase"),
  35     clEnumValN(CompilerDriver::TRANSLATION, "t",
  36       "Stop compilation after translation phase"),
  37     clEnumValN(CompilerDriver::OPTIMIZATION,"c",
  38       "Stop compilation after optimization phase"),
  39     clEnumValN(CompilerDriver::ASSEMBLY,"S",
  40       "Stop compilation after assembly phase"),
  41     clEnumValEnd
  42   )
  43 );
  44
  45 //===------------------------------------------------------------------------===
  46 //===          OPTIMIZATION OPTIONS
  47 //===------------------------------------------------------------------------===
  48 static cl::opt<CompilerDriver::OptimizationLevels> OptLevel(
  49   cl::desc("Choose level of optimization to apply:"),
  50   cl::init(CompilerDriver::OPT_FAST_COMPILE),
  51   cl::values(
  52     clEnumValN(CompilerDriver::OPT_FAST_COMPILE,"O0",
  53       "An alias for the -O1 option."),
  54     clEnumValN(CompilerDriver::OPT_FAST_COMPILE,"O1",
  55       "Optimize for compilation speed, not execution speed."),
  56     clEnumValN(CompilerDriver::OPT_SIMPLE,"O2",
  57       "Perform simple translation time optimizations"),
  58     clEnumValN(CompilerDriver::OPT_AGGRESSIVE,"O3",
  59       "Perform aggressive translation time optimizations"),
  60     clEnumValN(CompilerDriver::OPT_LINK_TIME,"O4",
  61       "Perform link time optimizations"),
  62     clEnumValN(CompilerDriver::OPT_AGGRESSIVE_LINK_TIME,"O5",
  63       "Perform aggressive link time optimizations"),
  64     clEnumValEnd
  65   )
  66 );
  67
  68 //===------------------------------------------------------------------------===
  69 //===          TOOL OPTIONS
  70 //===------------------------------------------------------------------------===
  71
  72 static cl::opt<std::string> PPToolOpts("Tpp", cl::ZeroOrMore,
  73   cl::desc("Pass specific options to the pre-processor"),
  74   cl::value_desc("option"));
  75
  76 static cl::opt<std::string> AsmToolOpts("Tasm", cl::ZeroOrMore,
  77   cl::desc("Pass specific options to the assembler"),
  78   cl::value_desc("option"));
  79
  80 static cl::opt<std::string> OptToolOpts("Topt", cl::ZeroOrMore,
  81   cl::desc("Pass specific options to the optimizer"),
  82   cl::value_desc("option"));
  83
  84 static cl::opt<std::string> LinkToolOpts("Tlink", cl::ZeroOrMore,
  85   cl::desc("Pass specific options to the linker"),
  86   cl::value_desc("option"));
  87
  88 //===------------------------------------------------------------------------===
  89 //===          INPUT OPTIONS
  90 //===------------------------------------------------------------------------===
  91
  92 static cl::list<std::string> LibPaths("L", cl::Prefix,
  93   cl::desc("Specify a library search path"), cl::value_desc("directory"));
  94
  95 static cl::list<std::string> Libraries("l", cl::Prefix,
  96   cl::desc("Specify libraries to link to"), cl::value_desc("library prefix"));
  97
  98
  99 //===------------------------------------------------------------------------===
 100 //===          OUTPUT OPTIONS
 101 //===------------------------------------------------------------------------===
 102
 103 static cl::opt<std::string> OutputFilename("o",
 104   cl::desc("Override output filename"), cl::value_desc("filename"));
 105
 106 static cl::opt<std::string> OutputMachine("m", cl::Prefix,
 107   cl::desc("Specify a target machine"), cl::value_desc("machine"));
 108
 109 static cl::opt<bool> Native("native", cl::init(false),
 110   cl::desc("Generative native object and executables instead of bytecode"));
 111
 112 //===------------------------------------------------------------------------===
 113 //===          INFORMATION OPTIONS
 114 //===------------------------------------------------------------------------===
 115
 116 static cl::opt<bool> DryRun("dry-run", cl::Optional, cl::init(false),
 117   cl::desc("Do everything but perform the compilation actions"));
 118
 119 static cl::alias DryRunAlias("y", cl::Optional,
 120   cl::desc("Alias for -dry-run"), cl::aliasopt(DryRun));
 121
 122 static cl::opt<bool> Verbose("verbose", cl::Optional, cl::init(false),
 123   cl::desc("Print out each action taken"));
 124
 125 static cl::alias VerboseAlias("v", cl::Optional,
 126   cl::desc("Alias for -verbose"), cl::aliasopt(Verbose));
 127
 128 static cl::opt<bool> Debug("debug", cl::Optional, cl::init(false),
 129   cl::Hidden, cl::desc("Print out debugging information"));
 130
 131 static cl::alias DebugAlias("d", cl::Optional,
 132   cl::desc("Alias for -debug"), cl::aliasopt(Debug));
 133
 134 static cl::opt<bool> TimeActions("time-actions", cl::Optional, cl::init(false),
 135   cl::desc("Print execution time for each action taken"));
 136
 137 //===------------------------------------------------------------------------===
 138 //===          ADVANCED OPTIONS
 139 //===------------------------------------------------------------------------===
 140
 141 static cl::opt<std::string> ConfigDir("config-dir", cl::Optional,
 142   cl::desc("Specify a configuration directory to override defaults"),
 143   cl::value_desc("directory"));
 144
 145 static cl::opt<bool> EmitRawCode("emit-raw-code", cl::Hidden,
 146   cl::desc("Emit raw, unoptimized code"));
 147
 148 //===------------------------------------------------------------------------===
 149 //===          POSITIONAL OPTIONS
 150 //===------------------------------------------------------------------------===
 151
 152 static cl::list<std::string> Files(cl::Positional, cl::OneOrMore,
 153   cl::desc("[Sources/objects/libraries]"));
 154
 155 static cl::list<std::string> Languages("x", cl::ZeroOrMore,
 156   cl::desc("Specify the source language for subsequent files"),
 157   cl::value_desc("language"));
 158
 159 //===------------------------------------------------------------------------===
 160 //===          GetFileType - determine type of a file
 161 //===------------------------------------------------------------------------===
 162 const std::string GetFileType(const std::string& fname, unsigned pos ) {
 163   static std::vector<std::string>::iterator langIt = Languages.begin();
 164   static std::string CurrLang = "";
 165
 166   // If a -x LANG option has been specified ..
 167   if ( langIt != Languages.end() )
 168     // If the -x LANG option came before the current file on command line
 169     if ( Languages.getPosition( langIt - Languages.begin() ) < pos ) {
 170       // use that language
 171       CurrLang = *langIt++;
 172       return CurrLang;
 173     }
 174
 175   // If there's a current language in effect
 176   if (!CurrLang.empty())
 177     return CurrLang; // use that language
 178
 179   // otherwise just determine lang from the filename's suffix
 180   return fname.substr( fname.rfind('.',fname.size()) + 1 );
 181 }
 182
 183 } // end anonymous namespace
 184
 185
 186 /// @brief The main program for llvmc
 187 int main(int argc, char **argv) {
 188   // Make sure we print stack trace if we get bad signals
 189   PrintStackTraceOnErrorSignal();
 190
 191   // Parse the command line options
 192   cl::ParseCommandLineOptions(argc, argv,
 193     " LLVM Compilation Driver (llvmc)\n\n"
 194     "  This program provides easy invocation of the LLVM tool set\n"
 195     "  and source language compiler tools.\n"
 196   );
 197
 198   // Deal with unimplemented options.
 199   if (Native)
 200     std::cerr << argv[0] << ": Not implemented yet: -native";
 201   if (EmitRawCode)
 202     std::cerr << argv[0] << ": Not implemented yet: -emit-raw-code";
 203
 204   // Default the output file, only if we're going to try to link
 205   if (OutputFilename.empty() && OptLevel == CompilerDriver::LINKING)
 206     OutputFilename = "a.out";
 207
 208   // Construct the ConfigDataProvider object
 209   LLVMC_ConfigDataProvider Provider;
 210   Provider.setConfigDir(ConfigDir);
 211
 212   // Construct the CompilerDriver object
 213   CompilerDriver CD(Provider);
 214
 215   // Configure the driver based on options
 216   CD.setVerbose(Verbose);
 217   CD.setDebug(Debug);
 218   CD.setDryRun(DryRun);
 219   CD.setFinalPhase(FinalPhase);
 220   CD.setOptimization(OptLevel);
 221   CD.setOutputMachine(OutputMachine);
 222   CD.setEmitNativeCode(Native);
 223   CD.setEmitRawCode(EmitRawCode);
 224   std::vector<std::string>::iterator pathIt = LibPaths.begin();
 225   while ( pathIt != LibPaths.end() ) {
 226       CD.addLibraryPath( *pathIt++ );
 227   }
 228
 229   // Prepare the list of files to be compiled by the CompilerDriver.
 230   CompilerDriver::InputList InpList;
 231   std::vector<std::string>::iterator fileIt = Files.begin();
 232   std::vector<std::string>::iterator libIt  = Libraries.begin();
 233   unsigned libPos = 0, filePos = 0;
 234   while ( 1 ) {
 235     if ( libIt != Libraries.end() )
 236       libPos = Libraries.getPosition( libIt - Libraries.begin() );
 237     else
 238       libPos = 0;
 239     if ( fileIt != Files.end() )
 240       filePos = Files.getPosition( fileIt - Files.begin() );
 241     else
 242       filePos = 0;
 243
 244     if ( filePos != 0 && (libPos == 0 || filePos < libPos) ) {
 245       // Add a source file
 246       InpList.push_back( std::make_pair(*fileIt, GetFileType(*fileIt,filePos)));
 247       ++fileIt;
 248     }
 249     else if ( libPos != 0 && (filePos == 0 || libPos < filePos) ) {
 250       // Add a library
 251       InpList.push_back( std::make_pair(*libIt++,""));
 252     }
 253     else
 254       break; // we're done with the list
 255   }
 256
 257   // Tell the driver to do its thing
 258   int result = CD.execute(InpList,OutputFilename);
 259   if (result != 0) {
 260     std::cerr << argv[0] << ": Error executing actions. Terminated.\n";
 261     return result;
 262   }
 263
 264   // All is good, return success
 265   return 0;
 266 }