lib/Target/X86/TargetInfo/X86TargetInfo.cpp

   1 //===-- X86TargetInfo.cpp - X86 Target Implementation ---------------------===//
   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 #include "llvm/Module.h"
  11 #include "llvm/Target/TargetRegistry.h"
  12 using namespace llvm;
  13
  14 Target TheX86_32Target;
  15
  16 static unsigned X86_32_JITMatchQuality() {
  17 #if defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)
  18   return 10;
  19 #endif
  20   return 0;
  21 }
  22
  23 static unsigned X86_32_TripleMatchQuality(const std::string &TT) {
  24   // We strongly match "i[3-9]86-*".
  25   if (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
  26       TT[4] == '-' && TT[1] - '3' < 6)
  27     return 20;
  28
  29   return 0;
  30 }
  31
  32 static unsigned X86_32_ModuleMatchQuality(const Module &M) {
  33   // Check for a triple match.
  34   if (unsigned Q = X86_32_TripleMatchQuality(M.getTargetTriple()))
  35     return Q;
  36
  37   // If the target triple is something non-X86, we don't match.
  38   if (!M.getTargetTriple().empty()) return 0;
  39
  40   if (M.getEndianness()  == Module::LittleEndian &&
  41       M.getPointerSize() == Module::Pointer32)
  42     return 10;                                   // Weak match
  43   else if (M.getEndianness() != Module::AnyEndianness ||
  44            M.getPointerSize() != Module::AnyPointerSize)
  45     return 0;                                    // Match for some other target
  46
  47   return X86_32_JITMatchQuality()/2;
  48 }
  49
  50 Target TheX86_64Target;
  51
  52 static unsigned X86_64_JITMatchQuality() {
  53 #if defined(__x86_64__) || defined(_M_AMD64)
  54   return 10;
  55 #endif
  56   return 0;
  57 }
  58
  59 static unsigned X86_64_TripleMatchQuality(const std::string &TT) {
  60   // We strongly match "x86_64-*".
  61   if (TT.size() >= 7 && TT[0] == 'x' && TT[1] == '8' && TT[2] == '6' &&
  62       TT[3] == '_' && TT[4] == '6' && TT[5] == '4' && TT[6] == '-')
  63     return 20;
  64
  65   return 0;
  66 }
  67
  68 static unsigned X86_64_ModuleMatchQuality(const Module &M) {
  69   // Check for a triple match.
  70   if (unsigned Q = X86_64_TripleMatchQuality(M.getTargetTriple()))
  71     return Q;
  72
  73   // If the target triple is something non-X86-64, we don't match.
  74   if (!M.getTargetTriple().empty()) return 0;
  75
  76   if (M.getEndianness()  == Module::LittleEndian &&
  77       M.getPointerSize() == Module::Pointer64)
  78     return 10;                                   // Weak match
  79   else if (M.getEndianness() != Module::AnyEndianness ||
  80            M.getPointerSize() != Module::AnyPointerSize)
  81     return 0;                                    // Match for some other target
  82
  83   return X86_64_JITMatchQuality()/2;
  84 }
  85
  86 extern "C" void LLVMInitializeX86TargetInfo() {
  87   TargetRegistry::RegisterTarget(TheX86_32Target, "x86",
  88                                   "32-bit X86: Pentium-Pro and above",
  89                                   &X86_32_TripleMatchQuality,
  90                                   &X86_32_ModuleMatchQuality,
  91                                   &X86_32_JITMatchQuality);
  92
  93   TargetRegistry::RegisterTarget(TheX86_64Target, "x86-64",
  94                                   "64-bit X86: EM64T and AMD64",
  95                                   &X86_64_TripleMatchQuality,
  96                                   &X86_64_ModuleMatchQuality,
  97                                   &X86_64_JITMatchQuality);
  98 }