Use Function's arg_size() and size() methods.

[oota-llvm.git] / include / llvm / Target / TargetMachineRegistry.h

diff --git a/include/llvm/Target/TargetMachineRegistry.h b/include/llvm/Target/TargetMachineRegistry.h
index a6038458cbe605f9676c703b4f17b952a7e82a96..2607ad5e639194d8167852ef1e6bab16cbf4459f 100644 (file)
--- a/include/llvm/Target/TargetMachineRegistry.h
+++ b/include/llvm/Target/TargetMachineRegistry.h
@@ -1,10 +1,10 @@
 //===-- 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 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
@@ -17,60 +17,80 @@
 #ifndef LLVM_TARGET_TARGETMACHINEREGISTRY_H
 #define LLVM_TARGET_TARGETMACHINEREGISTRY_H
 
+#include "llvm/Support/Registry.h"
+
 namespace llvm {
   class Module;
   class TargetMachine;
-  class IntrinsicLowering;
-
-  struct TargetMachineRegistry {
-    /// Entry - One instance of this struct is created for each target that is
-    /// registered.
-    struct Entry {
-      const char *Name;
-      const char *ShortDesc;
-      TargetMachine *(*CtorFn)(const Module &, IntrinsicLowering*);
-      unsigned (*ModuleMatchQualityFn)(const Module &M);
-      unsigned (*JITMatchQualityFn)();
-
-      const Entry *getNext() const { return Next; }
-
-    protected:
-      Entry(const char *N, const char *SD,
-            TargetMachine *(*CF)(const Module &, IntrinsicLowering*),
-            unsigned (*MMF)(const Module &M), unsigned (*JMF)())
+  
+  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), Next(List) {
-        List = this;
-      }
-    private:
-      const Entry *Next;  // Next entry in the linked list.
-    };
+        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; }
+  };
 
-    /// TargetMachineRegistry::getList - This static method returns the list of
-    /// target machines that are registered with the system.
-    static const Entry *getList() { return List; }
+  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);
 
-  private:
-    static const Entry *List;
   };
 
   //===--------------------------------------------------------------------===//
   /// 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..
+  /// 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 : public TargetMachineRegistry::Entry {
-    RegisterTarget(const char *Name, const char *ShortDesc) : 
-      TargetMachineRegistry::Entry(Name, ShortDesc, &Allocator,
-                                   &TargetMachineImpl::getModuleMatchQuality,
-                                   &TargetMachineImpl::getJITMatchQuality) {
-    }
+  struct RegisterTarget {
+    RegisterTarget(const char *Name, const char *ShortDesc)
+      : Entry(Name, ShortDesc, &Allocator,
+              &TargetMachineImpl::getModuleMatchQuality,
+              &TargetMachineImpl::getJITMatchQuality),
+        Node(Entry)
+    {}
+
   private:
-    static TargetMachine *Allocator(const Module &M, IntrinsicLowering *IL) {
-      return new TargetMachineImpl(M, IL);
+    TargetMachineRegistry::entry Entry;
+    TargetMachineRegistry::node Node;
+    
+    static TargetMachine *Allocator(const Module &M, const std::string &FS) {
+      return new TargetMachineImpl(M, FS);
     }
   };
+
 }
 
 #endif