← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/utils/TableGen/TableGen.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/utils/TableGen/TableGen.cpp
 
1
//===- TableGen.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 "AsmMatcherEmitter.h"
 
19
#include "AsmWriterEmitter.h"
 
20
#include "CallingConvEmitter.h"
 
21
#include "ClangDiagnosticsEmitter.h"
 
22
#include "CodeEmitterGen.h"
 
23
#include "DAGISelEmitter.h"
 
24
#include "DisassemblerEmitter.h"
 
25
#include "EDEmitter.h"
 
26
#include "FastISelEmitter.h"
 
27
#include "InstrEnumEmitter.h"
 
28
#include "InstrInfoEmitter.h"
 
29
#include "IntrinsicEmitter.h"
 
30
#include "LLVMCConfigurationEmitter.h"
 
31
#include "OptParserEmitter.h"
 
32
#include "Record.h"
 
33
#include "RegisterInfoEmitter.h"
 
34
#include "SubtargetEmitter.h"
 
35
#include "TGParser.h"
 
36
#include "llvm/Support/CommandLine.h"
 
37
#include "llvm/Support/FileUtilities.h"
 
38
#include "llvm/Support/MemoryBuffer.h"
 
39
#include "llvm/Support/PrettyStackTrace.h"
 
40
#include "llvm/Support/raw_ostream.h"
 
41
#include "llvm/System/Signals.h"
 
42
#include <algorithm>
 
43
#include <cstdio>
 
44
using namespace llvm;
 
45
 
 
46
enum ActionType {
 
47
  PrintRecords,
 
48
  GenEmitter,
 
49
  GenRegisterEnums, GenRegister, GenRegisterHeader,
 
50
  GenInstrEnums, GenInstrs, GenAsmWriter, GenAsmMatcher,
 
51
  GenDisassembler,
 
52
  GenCallingConv,
 
53
  GenClangDiagsDefs,
 
54
  GenClangDiagGroups,
 
55
  GenDAGISel,
 
56
  GenFastISel,
 
57
  GenOptParserDefs, GenOptParserImpl,
 
58
  GenSubtarget,
 
59
  GenIntrinsic,
 
60
  GenTgtIntrinsic,
 
61
  GenLLVMCConf,
 
62
  GenEDHeader, GenEDInfo,
 
63
  PrintEnums
 
64
};
 
65
 
 
66
namespace {
 
67
  cl::opt<ActionType>
 
68
  Action(cl::desc("Action to perform:"),
 
69
         cl::values(clEnumValN(PrintRecords, "print-records",
 
70
                               "Print all records to stdout (default)"),
 
71
                    clEnumValN(GenEmitter, "gen-emitter",
 
72
                               "Generate machine code emitter"),
 
73
                    clEnumValN(GenRegisterEnums, "gen-register-enums",
 
74
                               "Generate enum values for registers"),
 
75
                    clEnumValN(GenRegister, "gen-register-desc",
 
76
                               "Generate a register info description"),
 
77
                    clEnumValN(GenRegisterHeader, "gen-register-desc-header",
 
78
                               "Generate a register info description header"),
 
79
                    clEnumValN(GenInstrEnums, "gen-instr-enums",
 
80
                               "Generate enum values for instructions"),
 
81
                    clEnumValN(GenInstrs, "gen-instr-desc",
 
82
                               "Generate instruction descriptions"),
 
83
                    clEnumValN(GenCallingConv, "gen-callingconv",
 
84
                               "Generate calling convention descriptions"),
 
85
                    clEnumValN(GenAsmWriter, "gen-asm-writer",
 
86
                               "Generate assembly writer"),
 
87
                    clEnumValN(GenDisassembler, "gen-disassembler",
 
88
                               "Generate disassembler"),
 
89
                    clEnumValN(GenAsmMatcher, "gen-asm-matcher",
 
90
                               "Generate assembly instruction matcher"),
 
91
                    clEnumValN(GenDAGISel, "gen-dag-isel",
 
92
                               "Generate a DAG instruction selector"),
 
93
                    clEnumValN(GenFastISel, "gen-fast-isel",
 
94
                               "Generate a \"fast\" instruction selector"),
 
95
                    clEnumValN(GenOptParserDefs, "gen-opt-parser-defs",
 
96
                               "Generate option definitions"),
 
97
                    clEnumValN(GenOptParserImpl, "gen-opt-parser-impl",
 
98
                               "Generate option parser implementation"),
 
99
                    clEnumValN(GenSubtarget, "gen-subtarget",
 
100
                               "Generate subtarget enumerations"),
 
101
                    clEnumValN(GenIntrinsic, "gen-intrinsic",
 
102
                               "Generate intrinsic information"),
 
103
                    clEnumValN(GenTgtIntrinsic, "gen-tgt-intrinsic",
 
104
                               "Generate target intrinsic information"),
 
105
                    clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",
 
106
                               "Generate Clang diagnostics definitions"),
 
107
                    clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",
 
108
                               "Generate Clang diagnostic groups"),
 
109
                    clEnumValN(GenLLVMCConf, "gen-llvmc",
 
110
                               "Generate LLVMC configuration library"),
 
111
                    clEnumValN(GenEDHeader, "gen-enhanced-disassembly-header",
 
112
                               "Generate enhanced disassembly info header"),
 
113
                    clEnumValN(GenEDInfo, "gen-enhanced-disassembly-info",
 
114
                               "Generate enhanced disassembly info"),
 
115
                    clEnumValN(PrintEnums, "print-enums",
 
116
                               "Print enum values for a class"),
 
117
                    clEnumValEnd));
 
118
 
 
119
  cl::opt<std::string>
 
120
  Class("class", cl::desc("Print Enum list for this class"),
 
121
        cl::value_desc("class name"));
 
122
 
 
123
  cl::opt<std::string>
 
124
  OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"),
 
125
                 cl::init("-"));
 
126
 
 
127
  cl::opt<std::string>
 
128
  InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
 
129
 
 
130
  cl::list<std::string>
 
131
  IncludeDirs("I", cl::desc("Directory of include files"),
 
132
              cl::value_desc("directory"), cl::Prefix);
 
133
  
 
134
  cl::opt<std::string>
 
135
  ClangComponent("clang-component",
 
136
                 cl::desc("Only use warnings from specified component"),
 
137
                 cl::value_desc("component"), cl::Hidden);
 
138
}
 
139
 
 
140
 
 
141
// FIXME: Eliminate globals from tblgen.
 
142
RecordKeeper llvm::Records;
 
143
 
 
144
static SourceMgr SrcMgr;
 
145
 
 
146
void llvm::PrintError(SMLoc ErrorLoc, const std::string &Msg) {
 
147
  SrcMgr.PrintMessage(ErrorLoc, Msg, "error");
 
148
}
 
149
 
 
150
 
 
151
 
 
152
/// ParseFile - this function begins the parsing of the specified tablegen
 
153
/// file.
 
154
static bool ParseFile(const std::string &Filename,
 
155
                      const std::vector<std::string> &IncludeDirs,
 
156
                      SourceMgr &SrcMgr) {
 
157
  std::string ErrorStr;
 
158
  MemoryBuffer *F = MemoryBuffer::getFileOrSTDIN(Filename.c_str(), &ErrorStr);
 
159
  if (F == 0) {
 
160
    errs() << "Could not open input file '" << Filename << "': " 
 
161
           << ErrorStr <<"\n";
 
162
    return true;
 
163
  }
 
164
  
 
165
  // Tell SrcMgr about this buffer, which is what TGParser will pick up.
 
166
  SrcMgr.AddNewSourceBuffer(F, SMLoc());
 
167
 
 
168
  // Record the location of the include directory so that the lexer can find
 
169
  // it later.
 
170
  SrcMgr.setIncludeDirs(IncludeDirs);
 
171
  
 
172
  TGParser Parser(SrcMgr);
 
173
 
 
174
  return Parser.ParseFile();
 
175
}
 
176
 
 
177
int main(int argc, char **argv) {
 
178
  sys::PrintStackTraceOnErrorSignal();
 
179
  PrettyStackTraceProgram X(argc, argv);
 
180
  cl::ParseCommandLineOptions(argc, argv);
 
181
 
 
182
  
 
183
  // Parse the input file.
 
184
  if (ParseFile(InputFilename, IncludeDirs, SrcMgr))
 
185
    return 1;
 
186
 
 
187
  raw_ostream *Out = &outs();
 
188
  if (OutputFilename != "-") {
 
189
    std::string Error;
 
190
    Out = new raw_fd_ostream(OutputFilename.c_str(), Error);
 
191
 
 
192
    if (!Error.empty()) {
 
193
      errs() << argv[0] << ": error opening " << OutputFilename 
 
194
             << ":" << Error << "\n";
 
195
      return 1;
 
196
    }
 
197
 
 
198
    // Make sure the file gets removed if *gasp* tablegen crashes...
 
199
    sys::RemoveFileOnSignal(sys::Path(OutputFilename));
 
200
  }
 
201
 
 
202
  try {
 
203
    switch (Action) {
 
204
    case PrintRecords:
 
205
      *Out << Records;           // No argument, dump all contents
 
206
      break;
 
207
    case GenEmitter:
 
208
      CodeEmitterGen(Records).run(*Out);
 
209
      break;
 
210
 
 
211
    case GenRegisterEnums:
 
212
      RegisterInfoEmitter(Records).runEnums(*Out);
 
213
      break;
 
214
    case GenRegister:
 
215
      RegisterInfoEmitter(Records).run(*Out);
 
216
      break;
 
217
    case GenRegisterHeader:
 
218
      RegisterInfoEmitter(Records).runHeader(*Out);
 
219
      break;
 
220
    case GenInstrEnums:
 
221
      InstrEnumEmitter(Records).run(*Out);
 
222
      break;
 
223
    case GenInstrs:
 
224
      InstrInfoEmitter(Records).run(*Out);
 
225
      break;
 
226
    case GenCallingConv:
 
227
      CallingConvEmitter(Records).run(*Out);
 
228
      break;
 
229
    case GenAsmWriter:
 
230
      AsmWriterEmitter(Records).run(*Out);
 
231
      break;
 
232
    case GenAsmMatcher:
 
233
      AsmMatcherEmitter(Records).run(*Out);
 
234
      break;
 
235
    case GenClangDiagsDefs:
 
236
      ClangDiagsDefsEmitter(Records, ClangComponent).run(*Out);
 
237
      break;
 
238
    case GenClangDiagGroups:
 
239
      ClangDiagGroupsEmitter(Records).run(*Out);
 
240
      break;
 
241
    case GenDisassembler:
 
242
      DisassemblerEmitter(Records).run(*Out);
 
243
      break;
 
244
    case GenOptParserDefs:
 
245
      OptParserEmitter(Records, true).run(*Out);
 
246
      break;
 
247
    case GenOptParserImpl:
 
248
      OptParserEmitter(Records, false).run(*Out);
 
249
      break;
 
250
    case GenDAGISel:
 
251
      DAGISelEmitter(Records).run(*Out);
 
252
      break;
 
253
    case GenFastISel:
 
254
      FastISelEmitter(Records).run(*Out);
 
255
      break;
 
256
    case GenSubtarget:
 
257
      SubtargetEmitter(Records).run(*Out);
 
258
      break;
 
259
    case GenIntrinsic:
 
260
      IntrinsicEmitter(Records).run(*Out);
 
261
      break;
 
262
    case GenTgtIntrinsic:
 
263
      IntrinsicEmitter(Records, true).run(*Out);
 
264
      break;
 
265
    case GenLLVMCConf:
 
266
      LLVMCConfigurationEmitter(Records).run(*Out);
 
267
      break;
 
268
    case GenEDHeader:
 
269
      EDEmitter(Records).runHeader(*Out);
 
270
      break;
 
271
    case GenEDInfo:
 
272
      EDEmitter(Records).run(*Out);
 
273
      break;
 
274
    case PrintEnums:
 
275
    {
 
276
      std::vector<Record*> Recs = Records.getAllDerivedDefinitions(Class);
 
277
      for (unsigned i = 0, e = Recs.size(); i != e; ++i)
 
278
        *Out << Recs[i]->getName() << ", ";
 
279
      *Out << "\n";
 
280
      break;
 
281
    }
 
282
    default:
 
283
      assert(1 && "Invalid Action");
 
284
      return 1;
 
285
    }
 
286
    
 
287
    if (Out != &outs())
 
288
      delete Out;                               // Close the file
 
289
    return 0;
 
290
    
 
291
  } catch (const TGError &Error) {
 
292
    errs() << argv[0] << ": error:\n";
 
293
    PrintError(Error.getLoc(), Error.getMessage());
 
294
    
 
295
  } catch (const std::string &Error) {
 
296
    errs() << argv[0] << ": " << Error << "\n";
 
297
  } catch (const char *Error) {
 
298
    errs() << argv[0] << ": " << Error << "\n";
 
299
  } catch (...) {
 
300
    errs() << argv[0] << ": Unknown unexpected exception occurred.\n";
 
301
  }
 
302
  
 
303
  if (Out != &outs()) {
 
304
    delete Out;                             // Close the file
 
305
    std::remove(OutputFilename.c_str());    // Remove the file, it's broken
 
306
  }
 
307
  return 1;
 
308
}