include/llvm/Target/TargetMachineRegistry.h

   1 //===-- Target/TargetMachineRegistry.h - Target Registration ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file exposes two classes: the TargetMachineRegistry class, which allows
  11 // tools to inspect all of registered targets, and the RegisterTarget class,
  12 // which TargetMachine implementations should use to register themselves with
  13 // the system.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_TARGET_TARGETMACHINEREGISTRY_H
  18 #define LLVM_TARGET_TARGETMACHINEREGISTRY_H
  19
  20 #include "Support/CommandLine.h"
  21
  22 namespace llvm {
  23   class Module;
  24   class TargetMachine;
  25   class IntrinsicLowering;
  26
  27   struct TargetMachineRegistry {
  28     struct Entry;
  29
  30     /// TargetMachineRegistry::getList - This static method returns the list of
  31     /// target machines that are registered with the system.
  32     static const Entry *getList() { return List; }
  33
  34     /// getClosestStaticTargetForModule - Given an LLVM module, pick the best
  35     /// target that is compatible with the module.  If no close target can be
  36     /// found, this returns null and sets the Error string to a reason.
  37     static const Entry *getClosestStaticTargetForModule(const Module &M,
  38                                                         std::string &Error);
  39
  40     /// getClosestTargetForJIT - Given an LLVM module, pick the best target that
  41     /// is compatible with the current host and the specified module.  If no
  42     /// close target can be found, this returns null and sets the Error string
  43     /// to a reason.
  44     static const Entry *getClosestTargetForJIT(std::string &Error);
  45
  46
  47     /// Entry - One instance of this struct is created for each target that is
  48     /// registered.
  49     struct Entry {
  50       const char *Name;
  51       const char *ShortDesc;
  52       TargetMachine *(*CtorFn)(const Module &, IntrinsicLowering*);
  53       unsigned (*ModuleMatchQualityFn)(const Module &M);
  54       unsigned (*JITMatchQualityFn)();
  55
  56       const Entry *getNext() const { return Next; }
  57
  58     protected:
  59       Entry(const char *N, const char *SD,
  60             TargetMachine *(*CF)(const Module &, IntrinsicLowering*),
  61             unsigned (*MMF)(const Module &M), unsigned (*JMF)())
  62       : Name(N), ShortDesc(SD), CtorFn(CF), ModuleMatchQualityFn(MMF),
  63       JITMatchQualityFn(JMF), Next(List) {
  64         List = this;
  65       }
  66     private:
  67       const Entry *Next;  // Next entry in the linked list.
  68     };
  69
  70   private:
  71     static const Entry *List;
  72   };
  73
  74   //===--------------------------------------------------------------------===//
  75   /// RegisterTarget - This class is used to make targets automatically register
  76   /// themselves with the tool they are linked.  Targets should define an
  77   /// instance of this and implement the static methods described in the
  78   /// TargetMachine comments..
  79   template<class TargetMachineImpl>
  80   struct RegisterTarget : public TargetMachineRegistry::Entry {
  81     RegisterTarget(const char *Name, const char *ShortDesc) :
  82       TargetMachineRegistry::Entry(Name, ShortDesc, &Allocator,
  83                                    &TargetMachineImpl::getModuleMatchQuality,
  84                                    &TargetMachineImpl::getJITMatchQuality) {
  85     }
  86   private:
  87     static TargetMachine *Allocator(const Module &M, IntrinsicLowering *IL) {
  88       return new TargetMachineImpl(M, IL);
  89     }
  90   };
  91
  92   //===--------------------------------------------------------------------===//
  93   /// TargetNameParser - This option can be used to provide a command line
  94   /// option to choose among the various registered targets (commonly -march).
  95   class TargetNameParser :
  96     public cl::parser<const TargetMachineRegistry::Entry*> {
  97   public:
  98     void initialize(cl::Option &O) {
  99       for (const TargetMachineRegistry::Entry *E =
 100              TargetMachineRegistry::getList(); E; E = E->getNext())
 101         Values.push_back(std::make_pair(E->Name,
 102                                         std::make_pair(E, E->ShortDesc)));
 103       cl::parser<const TargetMachineRegistry::Entry*>::initialize(O);
 104     }
 105   };
 106 }
 107
 108 #endif