llvm-6502/include/llvm/Target/TargetMachineRegistry.h

//===-- Target/TargetMachineRegistry.h - Target Registration ----*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file exposes two classes: the TargetMachineRegistry class, which allows
// tools to inspect all of registered targets, and the RegisterTarget class,
// which TargetMachine implementations should use to register themselves with
// the system.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_TARGET_TARGETMACHINEREGISTRY_H
#define LLVM_TARGET_TARGETMACHINEREGISTRY_H

#include "llvm/Support/Registry.h"

namespace llvm {
  class Module;
  class TargetMachine;
  
  struct TargetMachineRegistryEntry {
    const char *Name;
    const char *ShortDesc;
    TargetMachine *(*CtorFn)(const Module &, const std::string &);
    unsigned (*ModuleMatchQualityFn)(const Module &M);
    unsigned (*JITMatchQualityFn)();
    
  public:
    TargetMachineRegistryEntry(const char *N, const char *SD,
                      TargetMachine *(*CF)(const Module &, const std::string &),
                               unsigned (*MMF)(const Module &M),
                               unsigned (*JMF)())
      : Name(N), ShortDesc(SD), CtorFn(CF), ModuleMatchQualityFn(MMF),
        JITMatchQualityFn(JMF) {}
  };
  
  template<>
  class RegistryTraits<TargetMachine> {
  public:
    typedef TargetMachineRegistryEntry entry;
    
    static const char *nameof(const entry &Entry) { return Entry.Name; }
    static const char *descof(const entry &Entry) { return Entry.ShortDesc; }
  };

  struct TargetMachineRegistry : public Registry<TargetMachine> {
    /// getClosestStaticTargetForModule - Given an LLVM module, pick the best
    /// target that is compatible with the module.  If no close target can be
    /// found, this returns null and sets the Error string to a reason.
    static const entry *getClosestStaticTargetForModule(const Module &M,
                                                        std::string &Error);

    /// getClosestTargetForJIT - Pick the best target that is compatible with
    /// the current host.  If no close target can be found, this returns null
    /// and sets the Error string to a reason.
    static const entry *getClosestTargetForJIT(std::string &Error);

  };

  //===--------------------------------------------------------------------===//
  /// RegisterTarget - This class is used to make targets automatically register
  /// themselves with the tool they are linked.  Targets should define an
  /// instance of this and implement the static methods described in the
  /// TargetMachine comments.
  /// The type 'TargetMachineImpl' should provide a constructor with two 
  /// parameters:
  /// - const Module& M: the module that is being compiled:
  /// - const std::string& FS: target-specific string describing target 
  ///   flavour.
  
  template<class TargetMachineImpl>
  struct RegisterTarget {
    RegisterTarget(const char *Name, const char *ShortDesc)
      : Entry(Name, ShortDesc, &Allocator,
              &TargetMachineImpl::getModuleMatchQuality,
              &TargetMachineImpl::getJITMatchQuality),
        Node(Entry)
    {}

  private:
    TargetMachineRegistry::entry Entry;
    TargetMachineRegistry::node Node;
    
    static TargetMachine *Allocator(const Module &M, const std::string &FS) {
      return new TargetMachineImpl(M, FS);
    }
  };

}

#endif