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