lib/Target/X86/X86Subtarget.cpp

   1 //===-- X86Subtarget.cpp - X86 Subtarget Information ------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Nate Begeman and is distributed under the
   6 // University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the X86 specific subclass of TargetSubtarget.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "X86Subtarget.h"
  15 #include "X86GenSubtarget.inc"
  16 #include "llvm/Module.h"
  17 #include "llvm/Support/CommandLine.h"
  18 #include <iostream>
  19 using namespace llvm;
  20
  21 cl::opt<X86Subtarget::AsmWriterFlavorTy>
  22 AsmWriterFlavor("x86-asm-syntax", cl::init(X86Subtarget::unset),
  23   cl::desc("Choose style of code to emit from X86 backend:"),
  24   cl::values(
  25     clEnumValN(X86Subtarget::att,   "att",   "  Emit AT&T-style assembly"),
  26     clEnumValN(X86Subtarget::intel, "intel", "  Emit Intel-style assembly"),
  27     clEnumValEnd));
  28
  29 /// GetCpuIDAndInfo - Execute the specified cpuid and return the 4 values in the
  30 /// specified arguments.  If we can't run cpuid on the host, return true.
  31 static bool GetCpuIDAndInfo(unsigned value, unsigned *rEAX, unsigned *rEBX,
  32                             unsigned *rECX, unsigned *rEDX) {
  33 #if defined(__x86_64__)
  34   asm ("pushq\t%%rbx\n\t"
  35        "cpuid\n\t"
  36        "movl\t%%ebx, %%esi\n\t"
  37        "popq\t%%rbx"
  38        : "=a" (*rEAX),
  39          "=S" (*rEBX),
  40          "=c" (*rECX),
  41          "=d" (*rEDX)
  42        :  "a" (value));
  43   return false;
  44 #elif defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)
  45 #if defined(__GNUC__)
  46   asm ("pushl\t%%ebx\n\t"
  47        "cpuid\n\t"
  48        "movl\t%%ebx, %%esi\n\t"
  49        "popl\t%%ebx"
  50        : "=a" (*rEAX),
  51          "=S" (*rEBX),
  52          "=c" (*rECX),
  53          "=d" (*rEDX)
  54        :  "a" (value));
  55   return false;
  56 #elif defined(_MSC_VER)
  57   __asm {
  58     mov   eax,value
  59     cpuid
  60     mov   esi,rEAX
  61     mov   dword ptr [esi],eax
  62     mov   esi,rEBX
  63     mov   dword ptr [esi],ebx
  64     mov   esi,rECX
  65     mov   dword ptr [esi],ecx
  66     mov   esi,rEDX
  67     mov   dword ptr [esi],edx
  68   }
  69   return false;
  70 #endif
  71 #endif
  72   return true;
  73 }
  74
  75 static const char *GetCurrentX86CPU() {
  76   unsigned EAX = 0, EBX = 0, ECX = 0, EDX = 0;
  77   if (GetCpuIDAndInfo(0x1, &EAX, &EBX, &ECX, &EDX))
  78     return "generic";
  79   unsigned Family  = (EAX & (0xffffffff >> (32 - 4)) << 8) >> 8; // Bits 8 - 11
  80   unsigned Model   = (EAX & (0xffffffff >> (32 - 4)) << 4) >> 4; // Bits 4 - 7
  81   GetCpuIDAndInfo(0x80000001, &EAX, &EBX, &ECX, &EDX);
  82   bool Em64T = EDX & (1 << 29);
  83
  84   union {
  85     unsigned u[3];
  86     char     c[12];
  87   } text;
  88
  89   GetCpuIDAndInfo(0, &EAX, text.u+0, text.u+2, text.u+1);
  90   if (memcmp(text.c, "GenuineIntel", 12) == 0) {
  91     switch (Family) {
  92       case 3:
  93         return "i386";
  94       case 4:
  95         return "i486";
  96       case 5:
  97         switch (Model) {
  98         case 4:  return "pentium-mmx";
  99         default: return "pentium";
 100         }
 101       case 6:
 102         switch (Model) {
 103         case 1:  return "pentiumpro";
 104         case 3:
 105         case 5:
 106         case 6:  return "pentium2";
 107         case 7:
 108         case 8:
 109         case 10:
 110         case 11: return "pentium3";
 111         case 9:
 112         case 13: return "pentium-m";
 113         case 14: return "yonah";
 114         case 15: return "core2";
 115         default: return "i686";
 116         }
 117       case 15: {
 118         switch (Model) {
 119         case 3:
 120         case 4:
 121           return (Em64T) ? "nocona" : "prescott";
 122         default:
 123           return (Em64T) ? "x86-64" : "pentium4";
 124         }
 125       }
 126
 127     default:
 128       return "generic";
 129     }
 130   } else if (memcmp(text.c, "AuthenticAMD", 12) == 0) {
 131     // FIXME: this poorly matches the generated SubtargetFeatureKV table.  There
 132     // appears to be no way to generate the wide variety of AMD-specific targets
 133     // from the information returned from CPUID.
 134     switch (Family) {
 135       case 4:
 136         return "i486";
 137       case 5:
 138         switch (Model) {
 139         case 6:
 140         case 7:  return "k6";
 141         case 8:  return "k6-2";
 142         case 9:
 143         case 13: return "k6-3";
 144         default: return "pentium";
 145         }
 146       case 6:
 147         switch (Model) {
 148         case 4:  return "athlon-tbird";
 149         case 6:
 150         case 7:
 151         case 8:  return "athlon-mp";
 152         case 10: return "athlon-xp";
 153         default: return "athlon";
 154         }
 155       case 15:
 156         switch (Model) {
 157         case 5:  return "athlon-fx"; // also opteron
 158         default: return "athlon64";
 159         }
 160
 161     default:
 162       return "generic";
 163     }
 164   } else {
 165     return "generic";
 166   }
 167 }
 168
 169 X86Subtarget::X86Subtarget(const Module &M, const std::string &FS, bool is64Bit)
 170   :  AsmFlavor(AsmWriterFlavor)
 171   , X86SSELevel(NoMMXSSE)
 172   , X863DNowLevel(NoThreeDNow)
 173   , HasX86_64(false)
 174   , stackAlignment(8)
 175   // FIXME: this is a known good value for Yonah. How about others?
 176   , MinRepStrSizeThreshold(128)
 177   , Is64Bit(is64Bit)
 178   , TargetType(isELF) { // Default to ELF unless otherwise specified.
 179
 180   // Determine default and user specified characteristics
 181   std::string CPU = GetCurrentX86CPU();
 182
 183   // Parse features string.
 184   ParseSubtargetFeatures(FS, CPU);
 185
 186   if (Is64Bit && !HasX86_64) {
 187       std::cerr << "Warning: Generation of 64-bit code for a 32-bit processor "
 188                    "requested.\n";
 189       HasX86_64 = true;
 190   }
 191
 192   // Set the boolean corresponding to the current target triple, or the default
 193   // if one cannot be determined, to true.
 194   const std::string& TT = M.getTargetTriple();
 195   if (TT.length() > 5) {
 196     if (TT.find("cygwin") != std::string::npos ||
 197         TT.find("mingw")  != std::string::npos)
 198       TargetType = isCygwin;
 199     else if (TT.find("darwin") != std::string::npos)
 200       TargetType = isDarwin;
 201     else if (TT.find("win32") != std::string::npos)
 202       TargetType = isWindows;
 203   } else if (TT.empty()) {
 204 #if defined(__CYGWIN__) || defined(__MINGW32__)
 205     TargetType = isCygwin;
 206 #elif defined(__APPLE__)
 207     TargetType = isDarwin;
 208 #elif defined(_WIN32)
 209     TargetType = isWindows;
 210 #endif
 211   }
 212
 213   // If the asm syntax hasn't been overridden on the command line, use whatever
 214   // the target wants.
 215   if (AsmFlavor == X86Subtarget::unset) {
 216     if (TargetType == isWindows) {
 217       AsmFlavor = X86Subtarget::intel;
 218     } else {
 219       AsmFlavor = X86Subtarget::att;
 220     }
 221   }
 222
 223   if (TargetType == isDarwin || TargetType == isCygwin)
 224     stackAlignment = 16;
 225 }