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