lib/Target/TargetMachineRegistry.cpp

   1 //===-- TargetMachineRegistry.cpp - Target Auto Registration Impl ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file exposes the RegisterTarget class, which TargetMachine
  11 // implementations should use to register themselves with the system.  This file
  12 // also exposes the TargetMachineRegistry class, which allows tools to inspect
  13 // all of registered targets.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "llvm/Target/TargetMachineRegistry.h"
  18 #include <algorithm>
  19 using namespace llvm;
  20
  21 /// getClosestStaticTargetForModule - Given an LLVM module, pick the best target
  22 /// that is compatible with the module.  If no close target can be found, this
  23 /// returns null and sets the Error string to a reason.
  24 const TargetMachineRegistry::entry *
  25 TargetMachineRegistry::getClosestStaticTargetForModule(const Module &M,
  26                                                        std::string &Error) {
  27   std::vector<std::pair<unsigned, const entry *> > UsableTargets;
  28   for (Registry<TargetMachine>::iterator I = begin(), E = end(); I != E; ++I)
  29     if (unsigned Qual = I->ModuleMatchQualityFn(M))
  30       UsableTargets.push_back(std::make_pair(Qual, &*I));
  31
  32   if (UsableTargets.empty()) {
  33     Error = "No available targets are compatible with this module";
  34     return 0;
  35   } else if (UsableTargets.size() == 1)
  36     return UsableTargets.back().second;
  37
  38   // Otherwise, take the best target, but make sure we don't have two equally
  39   // good best targets.
  40   std::sort(UsableTargets.begin(), UsableTargets.end());
  41   if (UsableTargets.back().first ==UsableTargets[UsableTargets.size()-2].first){
  42     Error = "Cannot choose between targets \"" +
  43       std::string(UsableTargets.back().second->Name) + "\" and \"" +
  44       std::string(UsableTargets[UsableTargets.size()-2].second->Name) + "\"";
  45     return 0;
  46   }
  47   return UsableTargets.back().second;
  48 }
  49
  50 /// getClosestTargetForJIT - Pick the best target that is compatible with
  51 /// the current host.  If no close target can be found, this returns null
  52 /// and sets the Error string to a reason.
  53 const TargetMachineRegistry::entry *
  54 TargetMachineRegistry::getClosestTargetForJIT(std::string &Error) {
  55   std::vector<std::pair<unsigned, const entry *> > UsableTargets;
  56   for (Registry<TargetMachine>::iterator I = begin(), E = end(); I != E; ++I)
  57     if (unsigned Qual = I->JITMatchQualityFn())
  58       UsableTargets.push_back(std::make_pair(Qual, &*I));
  59
  60   if (UsableTargets.empty()) {
  61     Error = "No JIT is available for this host";
  62     return 0;
  63   } else if (UsableTargets.size() == 1)
  64     return UsableTargets.back().second;
  65
  66   // Otherwise, take the best target.  If there is a tie, just pick one.
  67   unsigned MaxQual = UsableTargets.front().first;
  68   const entry *MaxQualTarget = UsableTargets.front().second;
  69
  70   for (unsigned i = 1, e = UsableTargets.size(); i != e; ++i)
  71     if (UsableTargets[i].first > MaxQual) {
  72       MaxQual = UsableTargets[i].first;
  73       MaxQualTarget = UsableTargets[i].second;
  74     }
  75
  76   return MaxQualTarget;
  77 }
  78