Line data    Source code

       1             : //===- Main.cpp - Top-Level TableGen implementation -----------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // TableGen is a tool which can be used to build up a description of something,
      11             : // then invoke one or more "tablegen backends" to emit information about the
      12             : // description in some predefined format.  In practice, this is used by the LLVM
      13             : // code generators to automate generation of a code generator through a
      14             : // high-level description of the target.
      15             : //
      16             : //===----------------------------------------------------------------------===//
      17             : 
      18             : #include "llvm/TableGen/Main.h"
      19             : #include "TGParser.h"
      20             : #include "llvm/ADT/StringExtras.h"
      21             : #include "llvm/Support/CommandLine.h"
      22             : #include "llvm/Support/FileSystem.h"
      23             : #include "llvm/Support/MemoryBuffer.h"
      24             : #include "llvm/Support/ToolOutputFile.h"
      25             : #include "llvm/TableGen/Error.h"
      26             : #include "llvm/TableGen/Record.h"
      27             : #include <algorithm>
      28             : #include <cstdio>
      29             : #include <system_error>
      30             : using namespace llvm;
      31             : 
      32             : static cl::opt<std::string>
      33             : OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"),
      34             :                cl::init("-"));
      35             : 
      36             : static cl::opt<std::string>
      37             : DependFilename("d",
      38             :                cl::desc("Dependency filename"),
      39             :                cl::value_desc("filename"),
      40             :                cl::init(""));
      41             : 
      42             : static cl::opt<std::string>
      43             : InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
      44             : 
      45             : static cl::list<std::string>
      46             : IncludeDirs("I", cl::desc("Directory of include files"),
      47             :             cl::value_desc("directory"), cl::Prefix);
      48             : 
      49           3 : static int reportError(const char *ProgName, Twine Msg) {
      50           3 :   errs() << ProgName << ": " << Msg;
      51           3 :   errs().flush();
      52           3 :   return 1;
      53             : }
      54             : 
      55             : /// Create a dependency file for `-d` option.
      56             : ///
      57             : /// This functionality is really only for the benefit of the build system.
      58             : /// It is similar to GCC's `-M*` family of options.
      59           0 : static int createDependencyFile(const TGParser &Parser, const char *argv0) {
      60           0 :   if (OutputFilename == "-")
      61           0 :     return reportError(argv0, "the option -d must be used together with -o\n");
      62             : 
      63             :   std::error_code EC;
      64           0 :   ToolOutputFile DepOut(DependFilename, EC, sys::fs::F_Text);
      65           0 :   if (EC)
      66           0 :     return reportError(argv0, "error opening " + DependFilename + ":" +
      67           0 :                                   EC.message() + "\n");
      68           0 :   DepOut.os() << OutputFilename << ":";
      69           0 :   for (const auto &Dep : Parser.getDependencies()) {
      70             :     DepOut.os() << ' ' << Dep.first;
      71             :   }
      72           0 :   DepOut.os() << "\n";
      73             :   DepOut.keep();
      74           0 :   return 0;
      75             : }
      76             : 
      77         352 : int llvm::TableGenMain(char *argv0, TableGenMainFn *MainFn) {
      78         699 :   RecordKeeper Records;
      79             : 
      80             :   // Parse the input file.
      81             :   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
      82         352 :       MemoryBuffer::getFileOrSTDIN(InputFilename);
      83         352 :   if (std::error_code EC = FileOrErr.getError())
      84           0 :     return reportError(argv0, "Could not open input file '" + InputFilename +
      85           0 :                                   "': " + EC.message() + "\n");
      86             : 
      87             :   // Tell SrcMgr about this buffer, which is what TGParser will pick up.
      88        1056 :   SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
      89             : 
      90             :   // Record the location of the include directory so that the lexer can find
      91             :   // it later.
      92             :   SrcMgr.setIncludeDirs(IncludeDirs);
      93             : 
      94         347 :   TGParser Parser(SrcMgr, Records);
      95             : 
      96         352 :   if (Parser.ParseFile())
      97             :     return 1;
      98             : 
      99             :   std::error_code EC;
     100         346 :   ToolOutputFile Out(OutputFilename, EC, sys::fs::F_Text);
     101         346 :   if (EC)
     102           0 :     return reportError(argv0, "error opening " + OutputFilename + ":" +
     103           0 :                                   EC.message() + "\n");
     104         346 :   if (!DependFilename.empty()) {
     105           0 :     if (int Ret = createDependencyFile(Parser, argv0))
     106             :       return Ret;
     107             :   }
     108             : 
     109         346 :   if (MainFn(Out.os(), Records))
     110             :     return 1;
     111             : 
     112         344 :   if (ErrorsPrinted > 0)
     113           3 :     return reportError(argv0, Twine(ErrorsPrinted) + " errors.\n");
     114             : 
     115             :   // Declare success.
     116             :   Out.keep();
     117         341 :   return 0;
     118             : }