Use Bits.data() instead of &Bits[0].

[oota-llvm.git] / lib / Support / TargetRegistry.cpp

diff --git a/lib/Support/TargetRegistry.cpp b/lib/Support/TargetRegistry.cpp
index 258431a9372886b443604815ebfb7335da8b818d..5896447f5ea5f2b6c8949337248971d880dd780b 100644 (file)
--- a/lib/Support/TargetRegistry.cpp
+++ b/lib/Support/TargetRegistry.cpp
@@ -8,64 +8,40 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Target/TargetRegistry.h"
+#include "llvm/System/Host.h"
 #include <cassert>
 using namespace llvm;
 
 // Clients are responsible for avoid race conditions in registration.
 static Target *FirstTarget = 0;
 
-const Target *
-TargetRegistry::getClosestStaticTargetForTriple(const std::string &TT,
-                                                std::string &Error) {
-  Target *Best = 0, *EquallyBest = 0;
-  unsigned BestQuality = 0;
-  // FIXME: Use iterator.
-  for (Target *i = FirstTarget; i; i = i->Next) {
-    if (unsigned Qual = i->TripleMatchQualityFn(TT)) {
-      if (!Best || Qual > BestQuality) {
-        Best = i;
-        EquallyBest = 0;
-        BestQuality = Qual;
-      } else if (Qual == BestQuality)
-        EquallyBest = i;
-    }
-  }
-
-  if (!Best) {
-    Error = "No available targets are compatible with this module";
-    return 0;
-  }
+TargetRegistry::iterator TargetRegistry::begin() {
+  return iterator(FirstTarget);
+}
 
-  // Otherwise, take the best target, but make sure we don't have two equally
-  // good best targets.
-  if (EquallyBest) {
-    Error = std::string("Cannot choose between targets \"") +
-      Best->Name  + "\" and \"" + EquallyBest->Name + "\"";
+const Target *TargetRegistry::lookupTarget(const std::string &TT,
+                                           std::string &Error) {
+  // Provide special warning when no targets are initialized.
+  if (begin() == end()) {
+    Error = "Unable to find target for this triple (no targets are registered)";
     return 0;
   }
-
-  return Best;
-}
-
-const Target *
-TargetRegistry::getClosestStaticTargetForModule(const Module &M,
-                                                std::string &Error) {
-  Target *Best = 0, *EquallyBest = 0;
+  const Target *Best = 0, *EquallyBest = 0;
   unsigned BestQuality = 0;
-  // FIXME: Use iterator.
-  for (Target *i = FirstTarget; i; i = i->Next) {
-    if (unsigned Qual = i->ModuleMatchQualityFn(M)) {
+  for (iterator it = begin(), ie = end(); it != ie; ++it) {
+    if (unsigned Qual = it->TripleMatchQualityFn(TT)) {
       if (!Best || Qual > BestQuality) {
-        Best = i;
+        Best = &*it;
         EquallyBest = 0;
         BestQuality = Qual;
       } else if (Qual == BestQuality)
-        EquallyBest = i;
+        EquallyBest = &*it;
     }
   }
 
   if (!Best) {
-    Error = "No available targets are compatible with this module";
+    Error = "No available targets are compatible with this triple, "
+      "see -version for the available targets.";
     return 0;
   }
 
@@ -80,55 +56,37 @@ TargetRegistry::getClosestStaticTargetForModule(const Module &M,
   return Best;
 }
 
-const Target *
-TargetRegistry::getClosestTargetForJIT(std::string &Error) {
-  Target *Best = 0, *EquallyBest = 0;
-  unsigned BestQuality = 0;
-  // FIXME: Use iterator.
-  for (Target *i = FirstTarget; i; i = i->Next) {
-    if (unsigned Qual = i->JITMatchQualityFn()) {
-      if (!Best || Qual > BestQuality) {
-        Best = i;
-        EquallyBest = 0;
-        BestQuality = Qual;
-      } else if (Qual == BestQuality)
-        EquallyBest = i;
-    }
-  }
-
-  if (!Best) {
-    Error = "No JIT is available for this host";
-    return 0;
-  }
-
-  // Return the best, ignoring ties.
-  return Best;
-}
-
 void TargetRegistry::RegisterTarget(Target &T,
                                     const char *Name,
                                     const char *ShortDesc,
                                     Target::TripleMatchQualityFnTy TQualityFn,
-                                    Target::ModuleMatchQualityFnTy MQualityFn,
-                                    Target::JITMatchQualityFnTy JITQualityFn) {
-  // Note that we don't require the constructor functions already be defined, in
-  // case a module happens to initialize the optional functionality before the
-  // target.
-  assert(!T.Next && !T.Name && !T.ShortDesc && !T.TripleMatchQualityFn &&
-         !T.ModuleMatchQualityFn && !T.JITMatchQualityFn && 
-         "This Target already registered!");
-
-  assert(Name && ShortDesc && TQualityFn && MQualityFn && JITQualityFn &&
+                                    bool HasJIT) {
+  assert(Name && ShortDesc && TQualityFn &&
          "Missing required target information!");
+
+  // Check if this target has already been initialized, we allow this as a
+  // convenience to some clients.
+  if (T.Name)
+    return;
          
   // Add to the list of targets.
   T.Next = FirstTarget;
-  FirstTarget = T.Next;
+  FirstTarget = &T;
 
   T.Name = Name;
   T.ShortDesc = ShortDesc;
   T.TripleMatchQualityFn = TQualityFn;
-  T.ModuleMatchQualityFn = MQualityFn;
-  T.JITMatchQualityFn = JITQualityFn;
+  T.HasJIT = HasJIT;
+}
+
+const Target *TargetRegistry::getClosestTargetForJIT(std::string &Error) {
+  const Target *TheTarget = lookupTarget(sys::getHostTriple(), Error);
+
+  if (TheTarget && !TheTarget->hasJIT()) {
+    Error = "No JIT compatible target available for this host";
+    return 0;
+  }
+
+  return TheTarget;
 }