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