lib/Support/Host.cpp

   1 //===-- Host.cpp - Implement OS Host Concept --------------------*- C++ -*-===//
   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 implements the operating system Host concept.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/Host.h"
  15 #include "llvm/ADT/SmallVector.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/ADT/StringSwitch.h"
  18 #include "llvm/ADT/Triple.h"
  19 #include "llvm/Config/config.h"
  20 #include "llvm/Support/Debug.h"
  21 #include "llvm/Support/FileSystem.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 #include <string.h>
  24
  25 // Include the platform-specific parts of this class.
  26 #ifdef LLVM_ON_UNIX
  27 #include "Unix/Host.inc"
  28 #endif
  29 #ifdef LLVM_ON_WIN32
  30 #include "Windows/Host.inc"
  31 #endif
  32 #ifdef _MSC_VER
  33 #include <intrin.h>
  34 #endif
  35 #if defined(__APPLE__) && (defined(__ppc__) || defined(__powerpc__))
  36 #include <mach/mach.h>
  37 #include <mach/mach_host.h>
  38 #include <mach/host_info.h>
  39 #include <mach/machine.h>
  40 #endif
  41
  42 #define DEBUG_TYPE "host-detection"
  43
  44 //===----------------------------------------------------------------------===//
  45 //
  46 //  Implementations of the CPU detection routines
  47 //
  48 //===----------------------------------------------------------------------===//
  49
  50 using namespace llvm;
  51
  52 #if defined(__linux__)
  53 static ssize_t LLVM_ATTRIBUTE_UNUSED readCpuInfo(void *Buf, size_t Size) {
  54   // Note: We cannot mmap /proc/cpuinfo here and then process the resulting
  55   // memory buffer because the 'file' has 0 size (it can be read from only
  56   // as a stream).
  57
  58   int FD;
  59   std::error_code EC = sys::fs::openFileForRead("/proc/cpuinfo", FD);
  60   if (EC) {
  61     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << EC.message() << "\n");
  62     return -1;
  63   }
  64   int Ret = read(FD, Buf, Size);
  65   int CloseStatus = close(FD);
  66   if (CloseStatus)
  67     return -1;
  68   return Ret;
  69 }
  70 #endif
  71
  72 #if defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)\
  73  || defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
  74
  75 /// GetX86CpuIDAndInfo - Execute the specified cpuid and return the 4 values in the
  76 /// specified arguments.  If we can't run cpuid on the host, return true.
  77 static bool GetX86CpuIDAndInfo(unsigned value, unsigned *rEAX, unsigned *rEBX,
  78                                unsigned *rECX, unsigned *rEDX) {
  79 #if defined(__GNUC__) || defined(__clang__)
  80   #if defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
  81     // gcc doesn't know cpuid would clobber ebx/rbx. Preseve it manually.
  82     asm ("movq\t%%rbx, %%rsi\n\t"
  83          "cpuid\n\t"
  84          "xchgq\t%%rbx, %%rsi\n\t"
  85          : "=a" (*rEAX),
  86            "=S" (*rEBX),
  87            "=c" (*rECX),
  88            "=d" (*rEDX)
  89          :  "a" (value));
  90     return false;
  91   #elif defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)
  92     asm ("movl\t%%ebx, %%esi\n\t"
  93          "cpuid\n\t"
  94          "xchgl\t%%ebx, %%esi\n\t"
  95          : "=a" (*rEAX),
  96            "=S" (*rEBX),
  97            "=c" (*rECX),
  98            "=d" (*rEDX)
  99          :  "a" (value));
 100     return false;
 101 // pedantic #else returns to appease -Wunreachable-code (so we don't generate
 102 // postprocessed code that looks like "return true; return false;")
 103   #else
 104     return true;
 105   #endif
 106 #elif defined(_MSC_VER)
 107   // The MSVC intrinsic is portable across x86 and x64.
 108   int registers[4];
 109   __cpuid(registers, value);
 110   *rEAX = registers[0];
 111   *rEBX = registers[1];
 112   *rECX = registers[2];
 113   *rEDX = registers[3];
 114   return false;
 115 #else
 116   return true;
 117 #endif
 118 }
 119
 120 /// GetX86CpuIDAndInfoEx - Execute the specified cpuid with subleaf and return the
 121 /// 4 values in the specified arguments.  If we can't run cpuid on the host,
 122 /// return true.
 123 static bool GetX86CpuIDAndInfoEx(unsigned value, unsigned subleaf,
 124                                  unsigned *rEAX, unsigned *rEBX, unsigned *rECX,
 125                                  unsigned *rEDX) {
 126 #if defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
 127   #if defined(__GNUC__)
 128     // gcc doesn't know cpuid would clobber ebx/rbx. Preseve it manually.
 129     asm ("movq\t%%rbx, %%rsi\n\t"
 130          "cpuid\n\t"
 131          "xchgq\t%%rbx, %%rsi\n\t"
 132          : "=a" (*rEAX),
 133            "=S" (*rEBX),
 134            "=c" (*rECX),
 135            "=d" (*rEDX)
 136          :  "a" (value),
 137             "c" (subleaf));
 138     return false;
 139   #elif defined(_MSC_VER)
 140     int registers[4];
 141     __cpuidex(registers, value, subleaf);
 142     *rEAX = registers[0];
 143     *rEBX = registers[1];
 144     *rECX = registers[2];
 145     *rEDX = registers[3];
 146     return false;
 147   #else
 148     return true;
 149   #endif
 150 #elif defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)
 151   #if defined(__GNUC__)
 152     asm ("movl\t%%ebx, %%esi\n\t"
 153          "cpuid\n\t"
 154          "xchgl\t%%ebx, %%esi\n\t"
 155          : "=a" (*rEAX),
 156            "=S" (*rEBX),
 157            "=c" (*rECX),
 158            "=d" (*rEDX)
 159          :  "a" (value),
 160             "c" (subleaf));
 161     return false;
 162   #elif defined(_MSC_VER)
 163     __asm {
 164       mov   eax,value
 165       mov   ecx,subleaf
 166       cpuid
 167       mov   esi,rEAX
 168       mov   dword ptr [esi],eax
 169       mov   esi,rEBX
 170       mov   dword ptr [esi],ebx
 171       mov   esi,rECX
 172       mov   dword ptr [esi],ecx
 173       mov   esi,rEDX
 174       mov   dword ptr [esi],edx
 175     }
 176     return false;
 177   #else
 178     return true;
 179   #endif
 180 #else
 181   return true;
 182 #endif
 183 }
 184
 185 static bool GetX86XCR0(unsigned *rEAX, unsigned *rEDX) {
 186 #if defined(__GNUC__)
 187   // Check xgetbv; this uses a .byte sequence instead of the instruction
 188   // directly because older assemblers do not include support for xgetbv and
 189   // there is no easy way to conditionally compile based on the assembler used.
 190   __asm__ (".byte 0x0f, 0x01, 0xd0" : "=a" (*rEAX), "=d" (*rEDX) : "c" (0));
 191   return false;
 192 #elif defined(_MSC_FULL_VER) && defined(_XCR_XFEATURE_ENABLED_MASK)
 193   unsigned long long Result = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
 194   *rEAX = Result;
 195   *rEDX = Result >> 32;
 196   return false;
 197 #else
 198   return true;
 199 #endif
 200 }
 201
 202 static void DetectX86FamilyModel(unsigned EAX, unsigned &Family,
 203                                  unsigned &Model) {
 204   Family = (EAX >> 8) & 0xf; // Bits 8 - 11
 205   Model  = (EAX >> 4) & 0xf; // Bits 4 - 7
 206   if (Family == 6 || Family == 0xf) {
 207     if (Family == 0xf)
 208       // Examine extended family ID if family ID is F.
 209       Family += (EAX >> 20) & 0xff;    // Bits 20 - 27
 210     // Examine extended model ID if family ID is 6 or F.
 211     Model += ((EAX >> 16) & 0xf) << 4; // Bits 16 - 19
 212   }
 213 }
 214
 215 StringRef sys::getHostCPUName() {
 216   unsigned EAX = 0, EBX = 0, ECX = 0, EDX = 0;
 217   if (GetX86CpuIDAndInfo(0x1, &EAX, &EBX, &ECX, &EDX))
 218     return "generic";
 219   unsigned Family = 0;
 220   unsigned Model  = 0;
 221   DetectX86FamilyModel(EAX, Family, Model);
 222
 223   union {
 224     unsigned u[3];
 225     char     c[12];
 226   } text;
 227
 228   GetX86CpuIDAndInfo(0, &EAX, text.u+0, text.u+2, text.u+1);
 229
 230   unsigned MaxLeaf = EAX;
 231   bool HasSSE3 = (ECX & 0x1);
 232   bool HasSSE41 = (ECX & 0x80000);
 233   // If CPUID indicates support for XSAVE, XRESTORE and AVX, and XGETBV
 234   // indicates that the AVX registers will be saved and restored on context
 235   // switch, then we have full AVX support.
 236   const unsigned AVXBits = (1 << 27) | (1 << 28);
 237   bool HasAVX = ((ECX & AVXBits) == AVXBits) && !GetX86XCR0(&EAX, &EDX) &&
 238                 ((EAX & 0x6) == 0x6);
 239   bool HasAVX2 = HasAVX && MaxLeaf >= 0x7 &&
 240                  !GetX86CpuIDAndInfoEx(0x7, 0x0, &EAX, &EBX, &ECX, &EDX) &&
 241                  (EBX & 0x20);
 242   GetX86CpuIDAndInfo(0x80000001, &EAX, &EBX, &ECX, &EDX);
 243   bool Em64T = (EDX >> 29) & 0x1;
 244   bool HasTBM = (ECX >> 21) & 0x1;
 245
 246   if (memcmp(text.c, "GenuineIntel", 12) == 0) {
 247     switch (Family) {
 248     case 3:
 249       return "i386";
 250     case 4:
 251       switch (Model) {
 252       case 0: // Intel486 DX processors
 253       case 1: // Intel486 DX processors
 254       case 2: // Intel486 SX processors
 255       case 3: // Intel487 processors, IntelDX2 OverDrive processors,
 256               // IntelDX2 processors
 257       case 4: // Intel486 SL processor
 258       case 5: // IntelSX2 processors
 259       case 7: // Write-Back Enhanced IntelDX2 processors
 260       case 8: // IntelDX4 OverDrive processors, IntelDX4 processors
 261       default: return "i486";
 262       }
 263     case 5:
 264       switch (Model) {
 265       case  1: // Pentium OverDrive processor for Pentium processor (60, 66),
 266                // Pentium processors (60, 66)
 267       case  2: // Pentium OverDrive processor for Pentium processor (75, 90,
 268                // 100, 120, 133), Pentium processors (75, 90, 100, 120, 133,
 269                // 150, 166, 200)
 270       case  3: // Pentium OverDrive processors for Intel486 processor-based
 271                // systems
 272         return "pentium";
 273
 274       case  4: // Pentium OverDrive processor with MMX technology for Pentium
 275                // processor (75, 90, 100, 120, 133), Pentium processor with
 276                // MMX technology (166, 200)
 277         return "pentium-mmx";
 278
 279       default: return "pentium";
 280       }
 281     case 6:
 282       switch (Model) {
 283       case  1: // Pentium Pro processor
 284         return "pentiumpro";
 285
 286       case  3: // Intel Pentium II OverDrive processor, Pentium II processor,
 287                // model 03
 288       case  5: // Pentium II processor, model 05, Pentium II Xeon processor,
 289                // model 05, and Intel Celeron processor, model 05
 290       case  6: // Celeron processor, model 06
 291         return "pentium2";
 292
 293       case  7: // Pentium III processor, model 07, and Pentium III Xeon
 294                // processor, model 07
 295       case  8: // Pentium III processor, model 08, Pentium III Xeon processor,
 296                // model 08, and Celeron processor, model 08
 297       case 10: // Pentium III Xeon processor, model 0Ah
 298       case 11: // Pentium III processor, model 0Bh
 299         return "pentium3";
 300
 301       case  9: // Intel Pentium M processor, Intel Celeron M processor model 09.
 302       case 13: // Intel Pentium M processor, Intel Celeron M processor, model
 303                // 0Dh. All processors are manufactured using the 90 nm process.
 304       case 21: // Intel EP80579 Integrated Processor and Intel EP80579
 305                // Integrated Processor with Intel QuickAssist Technology
 306         return "pentium-m";
 307
 308       case 14: // Intel Core Duo processor, Intel Core Solo processor, model
 309                // 0Eh. All processors are manufactured using the 65 nm process.
 310         return "yonah";
 311
 312       case 15: // Intel Core 2 Duo processor, Intel Core 2 Duo mobile
 313                // processor, Intel Core 2 Quad processor, Intel Core 2 Quad
 314                // mobile processor, Intel Core 2 Extreme processor, Intel
 315                // Pentium Dual-Core processor, Intel Xeon processor, model
 316                // 0Fh. All processors are manufactured using the 65 nm process.
 317       case 22: // Intel Celeron processor model 16h. All processors are
 318                // manufactured using the 65 nm process
 319         return "core2";
 320
 321       case 21: // Intel EP80579 Integrated Processor and Intel EP80579
 322                // Integrated Processor with Intel QuickAssist Technology
 323         return "i686"; // FIXME: ???
 324
 325       case 23: // Intel Core 2 Extreme processor, Intel Xeon processor, model
 326                // 17h. All processors are manufactured using the 45 nm process.
 327                //
 328                // 45nm: Penryn , Wolfdale, Yorkfield (XE)
 329       case 29: // Intel Xeon processor MP. All processors are manufactured using
 330                // the 45 nm process.
 331         // Not all Penryn processors support SSE 4.1 (such as the Pentium brand)
 332         return HasSSE41 ? "penryn" : "core2";
 333
 334       case 26: // Intel Core i7 processor and Intel Xeon processor. All
 335                // processors are manufactured using the 45 nm process.
 336       case 30: // Intel(R) Core(TM) i7 CPU         870  @ 2.93GHz.
 337                // As found in a Summer 2010 model iMac.
 338       case 37: // Intel Core i7, laptop version.
 339       case 44: // Intel Core i7 processor and Intel Xeon processor. All
 340                // processors are manufactured using the 32 nm process.
 341       case 46: // Nehalem EX
 342       case 47: // Westmere EX
 343         return "corei7";
 344
 345       // SandyBridge:
 346       case 42: // Intel Core i7 processor. All processors are manufactured
 347                // using the 32 nm process.
 348       case 45:
 349         // Not all Sandy Bridge processors support AVX (such as the Pentium
 350         // versions instead of the i7 versions).
 351         return HasAVX ? "corei7-avx" : "corei7";
 352
 353       // Ivy Bridge:
 354       case 58:
 355       case 62: // Ivy Bridge EP
 356         // Not all Ivy Bridge processors support AVX (such as the Pentium
 357         // versions instead of the i7 versions).
 358         return HasAVX ? "core-avx-i" : "corei7";
 359
 360       // Haswell:
 361       case 60:
 362       case 63:
 363       case 69:
 364       case 70:
 365         // Not all Haswell processors support AVX2 (such as the Pentium
 366         // versions instead of the i7 versions).
 367         return HasAVX2 ? "core-avx2" : "corei7";
 368
 369       // Broadwell:
 370       case 61:
 371         // Not all Broadwell processors support AVX2 (such as the Pentium
 372         // versions instead of the i7 versions).
 373         return HasAVX2 ? "broadwell" : "corei7";
 374
 375       case 28: // Most 45 nm Intel Atom processors
 376       case 38: // 45 nm Atom Lincroft
 377       case 39: // 32 nm Atom Medfield
 378       case 53: // 32 nm Atom Midview
 379       case 54: // 32 nm Atom Midview
 380         return "atom";
 381
 382       // Atom Silvermont codes from the Intel software optimization guide.
 383       case 55:
 384       case 74:
 385       case 77:
 386         return "slm";
 387
 388       default: return (Em64T) ? "x86-64" : "i686";
 389       }
 390     case 15: {
 391       switch (Model) {
 392       case  0: // Pentium 4 processor, Intel Xeon processor. All processors are
 393                // model 00h and manufactured using the 0.18 micron process.
 394       case  1: // Pentium 4 processor, Intel Xeon processor, Intel Xeon
 395                // processor MP, and Intel Celeron processor. All processors are
 396                // model 01h and manufactured using the 0.18 micron process.
 397       case  2: // Pentium 4 processor, Mobile Intel Pentium 4 processor - M,
 398                // Intel Xeon processor, Intel Xeon processor MP, Intel Celeron
 399                // processor, and Mobile Intel Celeron processor. All processors
 400                // are model 02h and manufactured using the 0.13 micron process.
 401         return (Em64T) ? "x86-64" : "pentium4";
 402
 403       case  3: // Pentium 4 processor, Intel Xeon processor, Intel Celeron D
 404                // processor. All processors are model 03h and manufactured using
 405                // the 90 nm process.
 406       case  4: // Pentium 4 processor, Pentium 4 processor Extreme Edition,
 407                // Pentium D processor, Intel Xeon processor, Intel Xeon
 408                // processor MP, Intel Celeron D processor. All processors are
 409                // model 04h and manufactured using the 90 nm process.
 410       case  6: // Pentium 4 processor, Pentium D processor, Pentium processor
 411                // Extreme Edition, Intel Xeon processor, Intel Xeon processor
 412                // MP, Intel Celeron D processor. All processors are model 06h
 413                // and manufactured using the 65 nm process.
 414         return (Em64T) ? "nocona" : "prescott";
 415
 416       default:
 417         return (Em64T) ? "x86-64" : "pentium4";
 418       }
 419     }
 420
 421     default:
 422       return "generic";
 423     }
 424   } else if (memcmp(text.c, "AuthenticAMD", 12) == 0) {
 425     // FIXME: this poorly matches the generated SubtargetFeatureKV table.  There
 426     // appears to be no way to generate the wide variety of AMD-specific targets
 427     // from the information returned from CPUID.
 428     switch (Family) {
 429       case 4:
 430         return "i486";
 431       case 5:
 432         switch (Model) {
 433         case 6:
 434         case 7:  return "k6";
 435         case 8:  return "k6-2";
 436         case 9:
 437         case 13: return "k6-3";
 438         case 10: return "geode";
 439         default: return "pentium";
 440         }
 441       case 6:
 442         switch (Model) {
 443         case 4:  return "athlon-tbird";
 444         case 6:
 445         case 7:
 446         case 8:  return "athlon-mp";
 447         case 10: return "athlon-xp";
 448         default: return "athlon";
 449         }
 450       case 15:
 451         if (HasSSE3)
 452           return "k8-sse3";
 453         switch (Model) {
 454         case 1:  return "opteron";
 455         case 5:  return "athlon-fx"; // also opteron
 456         default: return "athlon64";
 457         }
 458       case 16:
 459         return "amdfam10";
 460       case 20:
 461         return "btver1";
 462       case 21:
 463         if (!HasAVX) // If the OS doesn't support AVX provide a sane fallback.
 464           return "btver1";
 465         if (Model >= 0x50)
 466           return "bdver4"; // 50h-6Fh: Excavator
 467         if (Model >= 0x30)
 468           return "bdver3"; // 30h-3Fh: Steamroller
 469         if (Model >= 0x10 || HasTBM)
 470           return "bdver2"; // 10h-1Fh: Piledriver
 471         return "bdver1";   // 00h-0Fh: Bulldozer
 472       case 22:
 473         if (!HasAVX) // If the OS doesn't support AVX provide a sane fallback.
 474           return "btver1";
 475         return "btver2";
 476     default:
 477       return "generic";
 478     }
 479   }
 480   return "generic";
 481 }
 482 #elif defined(__APPLE__) && (defined(__ppc__) || defined(__powerpc__))
 483 StringRef sys::getHostCPUName() {
 484   host_basic_info_data_t hostInfo;
 485   mach_msg_type_number_t infoCount;
 486
 487   infoCount = HOST_BASIC_INFO_COUNT;
 488   host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo,
 489             &infoCount);
 490
 491   if (hostInfo.cpu_type != CPU_TYPE_POWERPC) return "generic";
 492
 493   switch(hostInfo.cpu_subtype) {
 494   case CPU_SUBTYPE_POWERPC_601:   return "601";
 495   case CPU_SUBTYPE_POWERPC_602:   return "602";
 496   case CPU_SUBTYPE_POWERPC_603:   return "603";
 497   case CPU_SUBTYPE_POWERPC_603e:  return "603e";
 498   case CPU_SUBTYPE_POWERPC_603ev: return "603ev";
 499   case CPU_SUBTYPE_POWERPC_604:   return "604";
 500   case CPU_SUBTYPE_POWERPC_604e:  return "604e";
 501   case CPU_SUBTYPE_POWERPC_620:   return "620";
 502   case CPU_SUBTYPE_POWERPC_750:   return "750";
 503   case CPU_SUBTYPE_POWERPC_7400:  return "7400";
 504   case CPU_SUBTYPE_POWERPC_7450:  return "7450";
 505   case CPU_SUBTYPE_POWERPC_970:   return "970";
 506   default: ;
 507   }
 508
 509   return "generic";
 510 }
 511 #elif defined(__linux__) && (defined(__ppc__) || defined(__powerpc__))
 512 StringRef sys::getHostCPUName() {
 513   // Access to the Processor Version Register (PVR) on PowerPC is privileged,
 514   // and so we must use an operating-system interface to determine the current
 515   // processor type. On Linux, this is exposed through the /proc/cpuinfo file.
 516   const char *generic = "generic";
 517
 518   // The cpu line is second (after the 'processor: 0' line), so if this
 519   // buffer is too small then something has changed (or is wrong).
 520   char buffer[1024];
 521   ssize_t CPUInfoSize = readCpuInfo(buffer, sizeof(buffer));
 522   if (CPUInfoSize == -1)
 523     return generic;
 524
 525   const char *CPUInfoStart = buffer;
 526   const char *CPUInfoEnd = buffer + CPUInfoSize;
 527
 528   const char *CIP = CPUInfoStart;
 529
 530   const char *CPUStart = 0;
 531   size_t CPULen = 0;
 532
 533   // We need to find the first line which starts with cpu, spaces, and a colon.
 534   // After the colon, there may be some additional spaces and then the cpu type.
 535   while (CIP < CPUInfoEnd && CPUStart == 0) {
 536     if (CIP < CPUInfoEnd && *CIP == '\n')
 537       ++CIP;
 538
 539     if (CIP < CPUInfoEnd && *CIP == 'c') {
 540       ++CIP;
 541       if (CIP < CPUInfoEnd && *CIP == 'p') {
 542         ++CIP;
 543         if (CIP < CPUInfoEnd && *CIP == 'u') {
 544           ++CIP;
 545           while (CIP < CPUInfoEnd && (*CIP == ' ' || *CIP == '\t'))
 546             ++CIP;
 547
 548           if (CIP < CPUInfoEnd && *CIP == ':') {
 549             ++CIP;
 550             while (CIP < CPUInfoEnd && (*CIP == ' ' || *CIP == '\t'))
 551               ++CIP;
 552
 553             if (CIP < CPUInfoEnd) {
 554               CPUStart = CIP;
 555               while (CIP < CPUInfoEnd && (*CIP != ' ' && *CIP != '\t' &&
 556                                           *CIP != ',' && *CIP != '\n'))
 557                 ++CIP;
 558               CPULen = CIP - CPUStart;
 559             }
 560           }
 561         }
 562       }
 563     }
 564
 565     if (CPUStart == 0)
 566       while (CIP < CPUInfoEnd && *CIP != '\n')
 567         ++CIP;
 568   }
 569
 570   if (CPUStart == 0)
 571     return generic;
 572
 573   return StringSwitch<const char *>(StringRef(CPUStart, CPULen))
 574     .Case("604e", "604e")
 575     .Case("604", "604")
 576     .Case("7400", "7400")
 577     .Case("7410", "7400")
 578     .Case("7447", "7400")
 579     .Case("7455", "7450")
 580     .Case("G4", "g4")
 581     .Case("POWER4", "970")
 582     .Case("PPC970FX", "970")
 583     .Case("PPC970MP", "970")
 584     .Case("G5", "g5")
 585     .Case("POWER5", "g5")
 586     .Case("A2", "a2")
 587     .Case("POWER6", "pwr6")
 588     .Case("POWER7", "pwr7")
 589     .Case("POWER8", "pwr8")
 590     .Case("POWER8E", "pwr8")
 591     .Default(generic);
 592 }
 593 #elif defined(__linux__) && defined(__arm__)
 594 StringRef sys::getHostCPUName() {
 595   // The cpuid register on arm is not accessible from user space. On Linux,
 596   // it is exposed through the /proc/cpuinfo file.
 597
 598   // Read 1024 bytes from /proc/cpuinfo, which should contain the CPU part line
 599   // in all cases.
 600   char buffer[1024];
 601   ssize_t CPUInfoSize = readCpuInfo(buffer, sizeof(buffer));
 602   if (CPUInfoSize == -1)
 603     return "generic";
 604
 605   StringRef Str(buffer, CPUInfoSize);
 606
 607   SmallVector<StringRef, 32> Lines;
 608   Str.split(Lines, "\n");
 609
 610   // Look for the CPU implementer line.
 611   StringRef Implementer;
 612   for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 613     if (Lines[I].startswith("CPU implementer"))
 614       Implementer = Lines[I].substr(15).ltrim("\t :");
 615
 616   if (Implementer == "0x41") // ARM Ltd.
 617     // Look for the CPU part line.
 618     for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 619       if (Lines[I].startswith("CPU part"))
 620         // The CPU part is a 3 digit hexadecimal number with a 0x prefix. The
 621         // values correspond to the "Part number" in the CP15/c0 register. The
 622         // contents are specified in the various processor manuals.
 623         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))
 624           .Case("0x926", "arm926ej-s")
 625           .Case("0xb02", "mpcore")
 626           .Case("0xb36", "arm1136j-s")
 627           .Case("0xb56", "arm1156t2-s")
 628           .Case("0xb76", "arm1176jz-s")
 629           .Case("0xc08", "cortex-a8")
 630           .Case("0xc09", "cortex-a9")
 631           .Case("0xc0f", "cortex-a15")
 632           .Case("0xc20", "cortex-m0")
 633           .Case("0xc23", "cortex-m3")
 634           .Case("0xc24", "cortex-m4")
 635           .Default("generic");
 636
 637   if (Implementer == "0x51") // Qualcomm Technologies, Inc.
 638     // Look for the CPU part line.
 639     for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 640       if (Lines[I].startswith("CPU part"))
 641         // The CPU part is a 3 digit hexadecimal number with a 0x prefix. The
 642         // values correspond to the "Part number" in the CP15/c0 register. The
 643         // contents are specified in the various processor manuals.
 644         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))
 645           .Case("0x06f", "krait") // APQ8064
 646           .Default("generic");
 647
 648   return "generic";
 649 }
 650 #elif defined(__linux__) && defined(__s390x__)
 651 StringRef sys::getHostCPUName() {
 652   // STIDP is a privileged operation, so use /proc/cpuinfo instead.
 653
 654   // The "processor 0:" line comes after a fair amount of other information,
 655   // including a cache breakdown, but this should be plenty.
 656   char buffer[2048];
 657   ssize_t CPUInfoSize = readCpuInfo(buffer, sizeof(buffer));
 658   if (CPUInfoSize == -1)
 659     return "generic";
 660
 661   StringRef Str(buffer, CPUInfoSize);
 662   SmallVector<StringRef, 32> Lines;
 663   Str.split(Lines, "\n");
 664   for (unsigned I = 0, E = Lines.size(); I != E; ++I) {
 665     if (Lines[I].startswith("processor ")) {
 666       size_t Pos = Lines[I].find("machine = ");
 667       if (Pos != StringRef::npos) {
 668         Pos += sizeof("machine = ") - 1;
 669         unsigned int Id;
 670         if (!Lines[I].drop_front(Pos).getAsInteger(10, Id)) {
 671           if (Id >= 2827)
 672             return "zEC12";
 673           if (Id >= 2817)
 674             return "z196";
 675         }
 676       }
 677       break;
 678     }
 679   }
 680
 681   return "generic";
 682 }
 683 #else
 684 StringRef sys::getHostCPUName() {
 685   return "generic";
 686 }
 687 #endif
 688
 689 #if defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)\
 690  || defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
 691 bool sys::getHostCPUFeatures(StringMap<bool> &Features) {
 692   unsigned EAX = 0, EBX = 0, ECX = 0, EDX = 0;
 693   unsigned MaxLevel;
 694   union {
 695     unsigned u[3];
 696     char     c[12];
 697   } text;
 698
 699   if (GetX86CpuIDAndInfo(0, &MaxLevel, text.u+0, text.u+2, text.u+1) ||
 700       MaxLevel < 1)
 701     return false;
 702
 703   GetX86CpuIDAndInfo(1, &EAX, &EBX, &ECX, &EDX);
 704
 705   Features["cmov"]   = (EDX >> 15) & 1;
 706   Features["mmx"]    = (EDX >> 23) & 1;
 707   Features["sse"]    = (EDX >> 25) & 1;
 708   Features["sse2"]   = (EDX >> 26) & 1;
 709   Features["sse3"]   = (ECX >>  0) & 1;
 710   Features["ssse3"]  = (ECX >>  9) & 1;
 711   Features["sse4.1"] = (ECX >> 19) & 1;
 712   Features["sse4.2"] = (ECX >> 20) & 1;
 713
 714   Features["pclmul"] = (ECX >>  1) & 1;
 715   Features["fma"]    = (ECX >> 12) & 1;
 716   Features["cx16"]   = (ECX >> 13) & 1;
 717   Features["movbe"]  = (ECX >> 22) & 1;
 718   Features["popcnt"] = (ECX >> 23) & 1;
 719   Features["aes"]    = (ECX >> 25) & 1;
 720   Features["f16c"]   = (ECX >> 29) & 1;
 721   Features["rdrnd"]  = (ECX >> 30) & 1;
 722
 723   // If CPUID indicates support for XSAVE, XRESTORE and AVX, and XGETBV
 724   // indicates that the AVX registers will be saved and restored on context
 725   // switch, then we have full AVX support.
 726   bool HasAVX = ((ECX >> 27) & 1) && ((ECX >> 28) & 1) &&
 727                 !GetX86XCR0(&EAX, &EDX) && ((EAX & 0x6) == 0x6);
 728   Features["avx"]    = HasAVX;
 729
 730   // AVX512 requires additional context to be saved by the OS.
 731   bool HasAVX512Save = HasAVX && ((EAX & 0xe0) == 0xe0);
 732
 733   unsigned MaxExtLevel;
 734   GetX86CpuIDAndInfo(0x80000000, &MaxExtLevel, &EBX, &ECX, &EDX);
 735
 736   bool HasExtLeaf1 = MaxExtLevel >= 0x80000001 &&
 737                      !GetX86CpuIDAndInfo(0x80000001, &EAX, &EBX, &ECX, &EDX);
 738   Features["lzcnt"]  = HasExtLeaf1 && ((ECX >>  5) & 1);
 739   Features["sse4a"]  = HasExtLeaf1 && ((ECX >>  6) & 1);
 740   Features["prfchw"] = HasExtLeaf1 && ((ECX >>  8) & 1);
 741   Features["xop"]    = HasExtLeaf1 && ((ECX >> 11) & 1);
 742   Features["fma4"]   = HasExtLeaf1 && ((ECX >> 16) & 1);
 743   Features["tbm"]    = HasExtLeaf1 && ((ECX >> 21) & 1);
 744
 745   bool HasLeaf7 = MaxLevel >= 7 &&
 746                   !GetX86CpuIDAndInfoEx(0x7, 0x0, &EAX, &EBX, &ECX, &EDX);
 747
 748   // AVX2 is only supported if we have the OS save support from AVX.
 749   Features["avx2"]     = HasAVX && HasLeaf7 && (EBX >>  5) & 1;
 750
 751   Features["fsgsbase"] = HasLeaf7 && ((EBX >>  0) & 1);
 752   Features["bmi"]      = HasLeaf7 && ((EBX >>  3) & 1);
 753   Features["hle"]      = HasLeaf7 && ((EBX >>  4) & 1);
 754   Features["bmi2"]     = HasLeaf7 && ((EBX >>  8) & 1);
 755   Features["rtm"]      = HasLeaf7 && ((EBX >> 11) & 1);
 756   Features["rdseed"]   = HasLeaf7 && ((EBX >> 18) & 1);
 757   Features["adx"]      = HasLeaf7 && ((EBX >> 19) & 1);
 758   Features["sha"]      = HasLeaf7 && ((EBX >> 29) & 1);
 759
 760   // AVX512 is only supported if the OS supports the context save for it.
 761   Features["avx512f"]  = HasLeaf7 && ((EBX >> 16) & 1) && HasAVX512Save;
 762   Features["avx512dq"] = HasLeaf7 && ((EBX >> 17) & 1) && HasAVX512Save;
 763   Features["avx512pf"] = HasLeaf7 && ((EBX >> 26) & 1) && HasAVX512Save;
 764   Features["avx512er"] = HasLeaf7 && ((EBX >> 27) & 1) && HasAVX512Save;
 765   Features["avx512cd"] = HasLeaf7 && ((EBX >> 28) & 1) && HasAVX512Save;
 766   Features["avx512bw"] = HasLeaf7 && ((EBX >> 30) & 1) && HasAVX512Save;
 767   Features["avx512vl"] = HasLeaf7 && ((EBX >> 31) & 1) && HasAVX512Save;
 768
 769   return true;
 770 }
 771 #elif defined(__linux__) && (defined(__arm__) || defined(__aarch64__))
 772 bool sys::getHostCPUFeatures(StringMap<bool> &Features) {
 773   // Read 1024 bytes from /proc/cpuinfo, which should contain the Features line
 774   // in all cases.
 775   char buffer[1024];
 776   ssize_t CPUInfoSize = readCpuInfo(buffer, sizeof(buffer));
 777   if (CPUInfoSize == -1)
 778     return false;
 779
 780   StringRef Str(buffer, CPUInfoSize);
 781
 782   SmallVector<StringRef, 32> Lines;
 783   Str.split(Lines, "\n");
 784
 785   SmallVector<StringRef, 32> CPUFeatures;
 786
 787   // Look for the CPU features.
 788   for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 789     if (Lines[I].startswith("Features")) {
 790       Lines[I].split(CPUFeatures, " ");
 791       break;
 792     }
 793
 794 #if defined(__aarch64__)
 795   // Keep track of which crypto features we have seen
 796   enum {
 797     CAP_AES   = 0x1,
 798     CAP_PMULL = 0x2,
 799     CAP_SHA1  = 0x4,
 800     CAP_SHA2  = 0x8
 801   };
 802   uint32_t crypto = 0;
 803 #endif
 804
 805   for (unsigned I = 0, E = CPUFeatures.size(); I != E; ++I) {
 806     StringRef LLVMFeatureStr = StringSwitch<StringRef>(CPUFeatures[I])
 807 #if defined(__aarch64__)
 808       .Case("asimd", "neon")
 809       .Case("fp", "fp-armv8")
 810       .Case("crc32", "crc")
 811 #else
 812       .Case("half", "fp16")
 813       .Case("neon", "neon")
 814       .Case("vfpv3", "vfp3")
 815       .Case("vfpv3d16", "d16")
 816       .Case("vfpv4", "vfp4")
 817       .Case("idiva", "hwdiv-arm")
 818       .Case("idivt", "hwdiv")
 819 #endif
 820       .Default("");
 821
 822 #if defined(__aarch64__)
 823     // We need to check crypto separately since we need all of the crypto
 824     // extensions to enable the subtarget feature
 825     if (CPUFeatures[I] == "aes")
 826       crypto |= CAP_AES;
 827     else if (CPUFeatures[I] == "pmull")
 828       crypto |= CAP_PMULL;
 829     else if (CPUFeatures[I] == "sha1")
 830       crypto |= CAP_SHA1;
 831     else if (CPUFeatures[I] == "sha2")
 832       crypto |= CAP_SHA2;
 833 #endif
 834
 835     if (LLVMFeatureStr != "")
 836       Features[LLVMFeatureStr] = true;
 837   }
 838
 839 #if defined(__aarch64__)
 840   // If we have all crypto bits we can add the feature
 841   if (crypto == (CAP_AES | CAP_PMULL | CAP_SHA1 | CAP_SHA2))
 842     Features["crypto"] = true;
 843 #endif
 844
 845   return true;
 846 }
 847 #else
 848 bool sys::getHostCPUFeatures(StringMap<bool> &Features){
 849   return false;
 850 }
 851 #endif
 852
 853 std::string sys::getProcessTriple() {
 854   Triple PT(Triple::normalize(LLVM_HOST_TRIPLE));
 855
 856   if (sizeof(void *) == 8 && PT.isArch32Bit())
 857     PT = PT.get64BitArchVariant();
 858   if (sizeof(void *) == 4 && PT.isArch64Bit())
 859     PT = PT.get32BitArchVariant();
 860
 861   return PT.str();
 862 }