← Back to branch summary

~ubuntu-branches/ubuntu/maverick/clamav/maverick-updates

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/Target/TargetRegistry.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-12-17 12:30:20 UTC
  • mfrom: (97.1.1 maverick-proposed)
  • Revision ID: james.westby@ubuntu.com-20101217123020-o02fhyzykv5z98ri
Tags: 0.96.5+dfsg-1ubuntu1.10.10.1
https://launchpad.net/bugs/691414
* Microversion update for Maverick (LP: #691414)
  - Improved database login times
  - Expanded use of new bytecode signatures
  - Other bugfixes/improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/Target/TargetRegistry.h
38
38
  class TargetAsmLexer;
39
39
  class TargetAsmParser;
40
40
  class TargetMachine;
41
 
  class formatted_raw_ostream;
42
41
  class raw_ostream;
43
42
 
44
43
  /// Target - Wrapper for Target specific information.
55
54
 
56
55
    typedef unsigned (*TripleMatchQualityFnTy)(const std::string &TT);
57
56
 
58
 
    typedef const MCAsmInfo *(*AsmInfoCtorFnTy)(const Target &T,
 
57
    typedef MCAsmInfo *(*AsmInfoCtorFnTy)(const Target &T,
59
58
                                                StringRef TT);
60
59
    typedef TargetMachine *(*TargetMachineCtorTy)(const Target &T,
61
60
                                                  const std::string &TT,
62
61
                                                  const std::string &Features);
63
 
    typedef AsmPrinter *(*AsmPrinterCtorTy)(formatted_raw_ostream &OS,
64
 
                                            TargetMachine &TM,
65
 
                                            MCContext &Ctx,
66
 
                                            MCStreamer &Streamer,
67
 
                                            const MCAsmInfo *MAI);
 
62
    typedef AsmPrinter *(*AsmPrinterCtorTy)(TargetMachine &TM,
 
63
                                            MCStreamer &Streamer);
68
64
    typedef TargetAsmBackend *(*AsmBackendCtorTy)(const Target &T,
69
 
                                                  MCAssembler &A);
 
65
                                                  const std::string &TT);
70
66
    typedef TargetAsmLexer *(*AsmLexerCtorTy)(const Target &T,
71
67
                                              const MCAsmInfo &MAI);
72
 
    typedef TargetAsmParser *(*AsmParserCtorTy)(const Target &T,MCAsmParser &P);
73
 
    typedef const MCDisassembler *(*MCDisassemblerCtorTy)(const Target &T);
 
68
    typedef TargetAsmParser *(*AsmParserCtorTy)(const Target &T,MCAsmParser &P,
 
69
                                                TargetMachine &TM);
 
70
    typedef MCDisassembler *(*MCDisassemblerCtorTy)(const Target &T);
74
71
    typedef MCInstPrinter *(*MCInstPrinterCtorTy)(const Target &T,
75
72
                                                  unsigned SyntaxVariant,
76
 
                                                  const MCAsmInfo &MAI,
77
 
                                                  raw_ostream &O);
 
73
                                                  const MCAsmInfo &MAI);
78
74
    typedef MCCodeEmitter *(*CodeEmitterCtorTy)(const Target &T,
79
75
                                                TargetMachine &TM,
80
76
                                                MCContext &Ctx);
 
77
    typedef MCStreamer *(*ObjectStreamerCtorTy)(const Target &T,
 
78
                                                const std::string &TT,
 
79
                                                MCContext &Ctx,
 
80
                                                TargetAsmBackend &TAB,
 
81
                                                raw_ostream &_OS,
 
82
                                                MCCodeEmitter *_Emitter,
 
83
                                                bool RelaxAll);
81
84
 
82
85
  private:
83
86
    /// Next - The next registered target in the linked list, maintained by the
131
134
    /// if registered.
132
135
    CodeEmitterCtorTy CodeEmitterCtorFn;
133
136
 
 
137
    /// ObjectStreamerCtorFn - Construction function for this target's
 
138
    /// ObjectStreamer, if registered.
 
139
    ObjectStreamerCtorTy ObjectStreamerCtorFn;
 
140
 
134
141
  public:
135
142
    /// @name Target Information
136
143
    /// @{
175
182
    /// hasCodeEmitter - Check if this target supports instruction encoding.
176
183
    bool hasCodeEmitter() const { return CodeEmitterCtorFn != 0; }
177
184
 
 
185
    /// hasObjectStreamer - Check if this target supports streaming to files.
 
186
    bool hasObjectStreamer() const { return ObjectStreamerCtorFn != 0; }
 
187
 
178
188
    /// @}
179
189
    /// @name Feature Constructors
180
190
    /// @{
186
196
    /// feature set; it should always be provided. Generally this should be
187
197
    /// either the target triple from the module, or the target triple of the
188
198
    /// host if that does not exist.
189
 
    const MCAsmInfo *createAsmInfo(StringRef Triple) const {
 
199
    MCAsmInfo *createAsmInfo(StringRef Triple) const {
190
200
      if (!AsmInfoCtorFn)
191
201
        return 0;
192
202
      return AsmInfoCtorFn(*this, Triple);
208
218
 
209
219
    /// createAsmBackend - Create a target specific assembly parser.
210
220
    ///
 
221
    /// \arg Triple - The target triple string.
211
222
    /// \arg Backend - The target independent assembler object.
212
 
    TargetAsmBackend *createAsmBackend(MCAssembler &Backend) const {
 
223
    TargetAsmBackend *createAsmBackend(const std::string &Triple) const {
213
224
      if (!AsmBackendCtorFn)
214
225
        return 0;
215
 
      return AsmBackendCtorFn(*this, Backend);
 
226
      return AsmBackendCtorFn(*this, Triple);
216
227
    }
217
228
 
218
229
    /// createAsmLexer - Create a target specific assembly lexer.
227
238
    ///
228
239
    /// \arg Parser - The target independent parser implementation to use for
229
240
    /// parsing and lexing.
230
 
    TargetAsmParser *createAsmParser(MCAsmParser &Parser) const {
 
241
    TargetAsmParser *createAsmParser(MCAsmParser &Parser,
 
242
                                     TargetMachine &TM) const {
231
243
      if (!AsmParserCtorFn)
232
244
        return 0;
233
 
      return AsmParserCtorFn(*this, Parser);
 
245
      return AsmParserCtorFn(*this, Parser, TM);
234
246
    }
235
247
 
236
248
    /// createAsmPrinter - Create a target specific assembly printer pass.  This
237
 
    /// takes ownership of the MCContext and MCStreamer objects but not the MAI.
238
 
    AsmPrinter *createAsmPrinter(formatted_raw_ostream &OS, TargetMachine &TM,
239
 
                                 MCContext &Ctx, MCStreamer &Streamer,
240
 
                                 const MCAsmInfo *MAI) const {
 
249
    /// takes ownership of the MCStreamer object.
 
250
    AsmPrinter *createAsmPrinter(TargetMachine &TM, MCStreamer &Streamer) const{
241
251
      if (!AsmPrinterCtorFn)
242
252
        return 0;
243
 
      return AsmPrinterCtorFn(OS, TM, Ctx, Streamer, MAI);
 
253
      return AsmPrinterCtorFn(TM, Streamer);
244
254
    }
245
255
 
246
 
    const MCDisassembler *createMCDisassembler() const {
 
256
    MCDisassembler *createMCDisassembler() const {
247
257
      if (!MCDisassemblerCtorFn)
248
258
        return 0;
249
259
      return MCDisassemblerCtorFn(*this);
250
260
    }
251
261
 
252
262
    MCInstPrinter *createMCInstPrinter(unsigned SyntaxVariant,
253
 
                                       const MCAsmInfo &MAI,
254
 
                                       raw_ostream &O) const {
 
263
                                       const MCAsmInfo &MAI) const {
255
264
      if (!MCInstPrinterCtorFn)
256
265
        return 0;
257
 
      return MCInstPrinterCtorFn(*this, SyntaxVariant, MAI, O);
 
266
      return MCInstPrinterCtorFn(*this, SyntaxVariant, MAI);
258
267
    }
259
268
 
260
269
 
265
274
      return CodeEmitterCtorFn(*this, TM, Ctx);
266
275
    }
267
276
 
 
277
    /// createObjectStreamer - Create a target specific MCStreamer.
 
278
    ///
 
279
    /// \arg TT - The target triple.
 
280
    /// \arg Ctx - The target context.
 
281
    /// \arg TAB - The target assembler backend object. Takes ownership.
 
282
    /// \arg _OS - The stream object.
 
283
    /// \arg _Emitter - The target independent assembler object.Takes ownership.
 
284
    /// \arg RelaxAll - Relax all fixups?
 
285
    MCStreamer *createObjectStreamer(const std::string &TT, MCContext &Ctx,
 
286
                                     TargetAsmBackend &TAB,
 
287
                                     raw_ostream &_OS,
 
288
                                     MCCodeEmitter *_Emitter,
 
289
                                     bool RelaxAll) const {
 
290
      if (!ObjectStreamerCtorFn)
 
291
        return 0;
 
292
      return ObjectStreamerCtorFn(*this, TT, Ctx, TAB, _OS, _Emitter, RelaxAll);
 
293
    }
 
294
 
268
295
    /// @}
269
296
  };
270
297
 
486
513
        T.CodeEmitterCtorFn = Fn;
487
514
    }
488
515
 
 
516
    /// RegisterObjectStreamer - Register an MCStreamer implementation
 
517
    /// for the given target.
 
518
    ///
 
519
    /// Clients are responsible for ensuring that registration doesn't occur
 
520
    /// while another thread is attempting to access the registry. Typically
 
521
    /// this is done by initializing all targets at program startup.
 
522
    ///
 
523
    /// @param T - The target being registered.
 
524
    /// @param Fn - A function to construct an MCStreamer for the target.
 
525
    static void RegisterObjectStreamer(Target &T, Target::ObjectStreamerCtorTy Fn) {
 
526
      if (!T.ObjectStreamerCtorFn)
 
527
        T.ObjectStreamerCtorFn = Fn;
 
528
    }
 
529
 
489
530
    /// @}
490
531
  };
491
532
 
531
572
      TargetRegistry::RegisterAsmInfo(T, &Allocator);
532
573
    }
533
574
  private:
534
 
    static const MCAsmInfo *Allocator(const Target &T, StringRef TT) {
 
575
    static MCAsmInfo *Allocator(const Target &T, StringRef TT) {
535
576
      return new MCAsmInfoImpl(T, TT);
536
577
    }
537
578
 
587
628
    }
588
629
 
589
630
  private:
590
 
    static TargetAsmBackend *Allocator(const Target &T, MCAssembler &Backend) {
591
 
      return new AsmBackendImpl(T, Backend);
 
631
    static TargetAsmBackend *Allocator(const Target &T,
 
632
                                       const std::string &Triple) {
 
633
      return new AsmBackendImpl(T, Triple);
592
634
    }
593
635
  };
594
636
 
627
669
    }
628
670
 
629
671
  private:
630
 
    static TargetAsmParser *Allocator(const Target &T, MCAsmParser &P) {
631
 
      return new AsmParserImpl(T, P);
 
672
    static TargetAsmParser *Allocator(const Target &T, MCAsmParser &P,
 
673
                                      TargetMachine &TM) {
 
674
      return new AsmParserImpl(T, P, TM);
632
675
    }
633
676
  };
634
677
 
647
690
    }
648
691
 
649
692
  private:
650
 
    static AsmPrinter *Allocator(formatted_raw_ostream &OS, TargetMachine &TM,
651
 
                                 MCContext &Ctx, MCStreamer &Streamer,
652
 
                                 const MCAsmInfo *MAI) {
653
 
      return new AsmPrinterImpl(OS, TM, Ctx, Streamer, MAI);
 
693
    static AsmPrinter *Allocator(TargetMachine &TM, MCStreamer &Streamer) {
 
694
      return new AsmPrinterImpl(TM, Streamer);
654
695
    }
655
696
  };
656
697