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   bool HasTBM = (ECX >> 21) & 0x1;
 227
 228   if (memcmp(text.c, "GenuineIntel", 12) == 0) {
 229     switch (Family) {
 230     case 3:
 231       return "i386";
 232     case 4:
 233       switch (Model) {
 234       case 0: // Intel486 DX processors
 235       case 1: // Intel486 DX processors
 236       case 2: // Intel486 SX processors
 237       case 3: // Intel487 processors, IntelDX2 OverDrive processors,
 238               // IntelDX2 processors
 239       case 4: // Intel486 SL processor
 240       case 5: // IntelSX2 processors
 241       case 7: // Write-Back Enhanced IntelDX2 processors
 242       case 8: // IntelDX4 OverDrive processors, IntelDX4 processors
 243       default: return "i486";
 244       }
 245     case 5:
 246       switch (Model) {
 247       case  1: // Pentium OverDrive processor for Pentium processor (60, 66),
 248                // Pentium processors (60, 66)
 249       case  2: // Pentium OverDrive processor for Pentium processor (75, 90,
 250                // 100, 120, 133), Pentium processors (75, 90, 100, 120, 133,
 251                // 150, 166, 200)
 252       case  3: // Pentium OverDrive processors for Intel486 processor-based
 253                // systems
 254         return "pentium";
 255
 256       case  4: // Pentium OverDrive processor with MMX technology for Pentium
 257                // processor (75, 90, 100, 120, 133), Pentium processor with
 258                // MMX technology (166, 200)
 259         return "pentium-mmx";
 260
 261       default: return "pentium";
 262       }
 263     case 6:
 264       switch (Model) {
 265       case  1: // Pentium Pro processor
 266         return "pentiumpro";
 267
 268       case  3: // Intel Pentium II OverDrive processor, Pentium II processor,
 269                // model 03
 270       case  5: // Pentium II processor, model 05, Pentium II Xeon processor,
 271                // model 05, and Intel Celeron processor, model 05
 272       case  6: // Celeron processor, model 06
 273         return "pentium2";
 274
 275       case  7: // Pentium III processor, model 07, and Pentium III Xeon
 276                // processor, model 07
 277       case  8: // Pentium III processor, model 08, Pentium III Xeon processor,
 278                // model 08, and Celeron processor, model 08
 279       case 10: // Pentium III Xeon processor, model 0Ah
 280       case 11: // Pentium III processor, model 0Bh
 281         return "pentium3";
 282
 283       case  9: // Intel Pentium M processor, Intel Celeron M processor model 09.
 284       case 13: // Intel Pentium M processor, Intel Celeron M processor, model
 285                // 0Dh. All processors are manufactured using the 90 nm process.
 286         return "pentium-m";
 287
 288       case 14: // Intel Core Duo processor, Intel Core Solo processor, model
 289                // 0Eh. All processors are manufactured using the 65 nm process.
 290         return "yonah";
 291
 292       case 15: // Intel Core 2 Duo processor, Intel Core 2 Duo mobile
 293                // processor, Intel Core 2 Quad processor, Intel Core 2 Quad
 294                // mobile processor, Intel Core 2 Extreme processor, Intel
 295                // Pentium Dual-Core processor, Intel Xeon processor, model
 296                // 0Fh. All processors are manufactured using the 65 nm process.
 297       case 22: // Intel Celeron processor model 16h. All processors are
 298                // manufactured using the 65 nm process
 299         return "core2";
 300
 301       case 21: // Intel EP80579 Integrated Processor and Intel EP80579
 302                // Integrated Processor with Intel QuickAssist Technology
 303         return "i686"; // FIXME: ???
 304
 305       case 23: // Intel Core 2 Extreme processor, Intel Xeon processor, model
 306                // 17h. All processors are manufactured using the 45 nm process.
 307                //
 308                // 45nm: Penryn , Wolfdale, Yorkfield (XE)
 309         // Not all Penryn processors support SSE 4.1 (such as the Pentium brand)
 310         return HasSSE41 ? "penryn" : "core2";
 311
 312       case 26: // Intel Core i7 processor and Intel Xeon processor. All
 313                // processors are manufactured using the 45 nm process.
 314       case 29: // Intel Xeon processor MP. All processors are manufactured using
 315                // the 45 nm process.
 316       case 30: // Intel(R) Core(TM) i7 CPU         870  @ 2.93GHz.
 317                // As found in a Summer 2010 model iMac.
 318       case 37: // Intel Core i7, laptop version.
 319       case 44: // Intel Core i7 processor and Intel Xeon processor. All
 320                // processors are manufactured using the 32 nm process.
 321       case 46: // Nehalem EX
 322       case 47: // Westmere EX
 323         return "corei7";
 324
 325       // SandyBridge:
 326       case 42: // Intel Core i7 processor. All processors are manufactured
 327                // using the 32 nm process.
 328       case 45:
 329         // Not all Sandy Bridge processors support AVX (such as the Pentium
 330         // versions instead of the i7 versions).
 331         return HasAVX ? "corei7-avx" : "corei7";
 332
 333       // Ivy Bridge:
 334       case 58:
 335       case 62: // Ivy Bridge EP
 336         // Not all Ivy Bridge processors support AVX (such as the Pentium
 337         // versions instead of the i7 versions).
 338         return HasAVX ? "core-avx-i" : "corei7";
 339
 340       // Haswell:
 341       case 60:
 342       case 63:
 343       case 69:
 344       case 70:
 345         // Not all Haswell processors support AVX too (such as the Pentium
 346         // versions instead of the i7 versions).
 347         return HasAVX2 ? "core-avx2" : "corei7";
 348
 349       case 28: // Most 45 nm Intel Atom processors
 350       case 38: // 45 nm Atom Lincroft
 351       case 39: // 32 nm Atom Medfield
 352       case 53: // 32 nm Atom Midview
 353       case 54: // 32 nm Atom Midview
 354         return "atom";
 355
 356       // Atom Silvermont codes from the Intel software optimization guide.
 357       case 55:
 358       case 74:
 359       case 77:
 360         return "slm";
 361
 362       default: return (Em64T) ? "x86-64" : "i686";
 363       }
 364     case 15: {
 365       switch (Model) {
 366       case  0: // Pentium 4 processor, Intel Xeon processor. All processors are
 367                // model 00h and manufactured using the 0.18 micron process.
 368       case  1: // Pentium 4 processor, Intel Xeon processor, Intel Xeon
 369                // processor MP, and Intel Celeron processor. All processors are
 370                // model 01h and manufactured using the 0.18 micron process.
 371       case  2: // Pentium 4 processor, Mobile Intel Pentium 4 processor - M,
 372                // Intel Xeon processor, Intel Xeon processor MP, Intel Celeron
 373                // processor, and Mobile Intel Celeron processor. All processors
 374                // are model 02h and manufactured using the 0.13 micron process.
 375         return (Em64T) ? "x86-64" : "pentium4";
 376
 377       case  3: // Pentium 4 processor, Intel Xeon processor, Intel Celeron D
 378                // processor. All processors are model 03h and manufactured using
 379                // the 90 nm process.
 380       case  4: // Pentium 4 processor, Pentium 4 processor Extreme Edition,
 381                // Pentium D processor, Intel Xeon processor, Intel Xeon
 382                // processor MP, Intel Celeron D processor. All processors are
 383                // model 04h and manufactured using the 90 nm process.
 384       case  6: // Pentium 4 processor, Pentium D processor, Pentium processor
 385                // Extreme Edition, Intel Xeon processor, Intel Xeon processor
 386                // MP, Intel Celeron D processor. All processors are model 06h
 387                // and manufactured using the 65 nm process.
 388         return (Em64T) ? "nocona" : "prescott";
 389
 390       default:
 391         return (Em64T) ? "x86-64" : "pentium4";
 392       }
 393     }
 394
 395     default:
 396       return "generic";
 397     }
 398   } else if (memcmp(text.c, "AuthenticAMD", 12) == 0) {
 399     // FIXME: this poorly matches the generated SubtargetFeatureKV table.  There
 400     // appears to be no way to generate the wide variety of AMD-specific targets
 401     // from the information returned from CPUID.
 402     switch (Family) {
 403       case 4:
 404         return "i486";
 405       case 5:
 406         switch (Model) {
 407         case 6:
 408         case 7:  return "k6";
 409         case 8:  return "k6-2";
 410         case 9:
 411         case 13: return "k6-3";
 412         case 10: return "geode";
 413         default: return "pentium";
 414         }
 415       case 6:
 416         switch (Model) {
 417         case 4:  return "athlon-tbird";
 418         case 6:
 419         case 7:
 420         case 8:  return "athlon-mp";
 421         case 10: return "athlon-xp";
 422         default: return "athlon";
 423         }
 424       case 15:
 425         if (HasSSE3)
 426           return "k8-sse3";
 427         switch (Model) {
 428         case 1:  return "opteron";
 429         case 5:  return "athlon-fx"; // also opteron
 430         default: return "athlon64";
 431         }
 432       case 16:
 433         return "amdfam10";
 434       case 20:
 435         return "btver1";
 436       case 21:
 437         if (!HasAVX) // If the OS doesn't support AVX provide a sane fallback.
 438           return "btver1";
 439         if (Model >= 0x50)
 440           return "bdver4"; // 50h-6Fh: Excavator
 441         if (Model >= 0x30)
 442           return "bdver3"; // 30h-3Fh: Steamroller
 443         if (Model >= 0x10 || HasTBM)
 444           return "bdver2"; // 10h-1Fh: Piledriver
 445         return "bdver1";   // 00h-0Fh: Bulldozer
 446       case 22:
 447         if (!HasAVX) // If the OS doesn't support AVX provide a sane fallback.
 448           return "btver1";
 449         return "btver2";
 450     default:
 451       return "generic";
 452     }
 453   }
 454   return "generic";
 455 }
 456 #elif defined(__APPLE__) && (defined(__ppc__) || defined(__powerpc__))
 457 StringRef sys::getHostCPUName() {
 458   host_basic_info_data_t hostInfo;
 459   mach_msg_type_number_t infoCount;
 460
 461   infoCount = HOST_BASIC_INFO_COUNT;
 462   host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo,
 463             &infoCount);
 464
 465   if (hostInfo.cpu_type != CPU_TYPE_POWERPC) return "generic";
 466
 467   switch(hostInfo.cpu_subtype) {
 468   case CPU_SUBTYPE_POWERPC_601:   return "601";
 469   case CPU_SUBTYPE_POWERPC_602:   return "602";
 470   case CPU_SUBTYPE_POWERPC_603:   return "603";
 471   case CPU_SUBTYPE_POWERPC_603e:  return "603e";
 472   case CPU_SUBTYPE_POWERPC_603ev: return "603ev";
 473   case CPU_SUBTYPE_POWERPC_604:   return "604";
 474   case CPU_SUBTYPE_POWERPC_604e:  return "604e";
 475   case CPU_SUBTYPE_POWERPC_620:   return "620";
 476   case CPU_SUBTYPE_POWERPC_750:   return "750";
 477   case CPU_SUBTYPE_POWERPC_7400:  return "7400";
 478   case CPU_SUBTYPE_POWERPC_7450:  return "7450";
 479   case CPU_SUBTYPE_POWERPC_970:   return "970";
 480   default: ;
 481   }
 482
 483   return "generic";
 484 }
 485 #elif defined(__linux__) && (defined(__ppc__) || defined(__powerpc__))
 486 StringRef sys::getHostCPUName() {
 487   // Access to the Processor Version Register (PVR) on PowerPC is privileged,
 488   // and so we must use an operating-system interface to determine the current
 489   // processor type. On Linux, this is exposed through the /proc/cpuinfo file.
 490   const char *generic = "generic";
 491
 492   // Note: We cannot mmap /proc/cpuinfo here and then process the resulting
 493   // memory buffer because the 'file' has 0 size (it can be read from only
 494   // as a stream).
 495
 496   std::string Err;
 497   DataStreamer *DS = getDataFileStreamer("/proc/cpuinfo", &Err);
 498   if (!DS) {
 499     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << Err << "\n");
 500     return generic;
 501   }
 502
 503   // The cpu line is second (after the 'processor: 0' line), so if this
 504   // buffer is too small then something has changed (or is wrong).
 505   char buffer[1024];
 506   size_t CPUInfoSize = DS->GetBytes((unsigned char*) buffer, sizeof(buffer));
 507   delete DS;
 508
 509   const char *CPUInfoStart = buffer;
 510   const char *CPUInfoEnd = buffer + CPUInfoSize;
 511
 512   const char *CIP = CPUInfoStart;
 513
 514   const char *CPUStart = 0;
 515   size_t CPULen = 0;
 516
 517   // We need to find the first line which starts with cpu, spaces, and a colon.
 518   // After the colon, there may be some additional spaces and then the cpu type.
 519   while (CIP < CPUInfoEnd && CPUStart == 0) {
 520     if (CIP < CPUInfoEnd && *CIP == '\n')
 521       ++CIP;
 522
 523     if (CIP < CPUInfoEnd && *CIP == 'c') {
 524       ++CIP;
 525       if (CIP < CPUInfoEnd && *CIP == 'p') {
 526         ++CIP;
 527         if (CIP < CPUInfoEnd && *CIP == 'u') {
 528           ++CIP;
 529           while (CIP < CPUInfoEnd && (*CIP == ' ' || *CIP == '\t'))
 530             ++CIP;
 531
 532           if (CIP < CPUInfoEnd && *CIP == ':') {
 533             ++CIP;
 534             while (CIP < CPUInfoEnd && (*CIP == ' ' || *CIP == '\t'))
 535               ++CIP;
 536
 537             if (CIP < CPUInfoEnd) {
 538               CPUStart = CIP;
 539               while (CIP < CPUInfoEnd && (*CIP != ' ' && *CIP != '\t' &&
 540                                           *CIP != ',' && *CIP != '\n'))
 541                 ++CIP;
 542               CPULen = CIP - CPUStart;
 543             }
 544           }
 545         }
 546       }
 547     }
 548
 549     if (CPUStart == 0)
 550       while (CIP < CPUInfoEnd && *CIP != '\n')
 551         ++CIP;
 552   }
 553
 554   if (CPUStart == 0)
 555     return generic;
 556
 557   return StringSwitch<const char *>(StringRef(CPUStart, CPULen))
 558     .Case("604e", "604e")
 559     .Case("604", "604")
 560     .Case("7400", "7400")
 561     .Case("7410", "7400")
 562     .Case("7447", "7400")
 563     .Case("7455", "7450")
 564     .Case("G4", "g4")
 565     .Case("POWER4", "970")
 566     .Case("PPC970FX", "970")
 567     .Case("PPC970MP", "970")
 568     .Case("G5", "g5")
 569     .Case("POWER5", "g5")
 570     .Case("A2", "a2")
 571     .Case("POWER6", "pwr6")
 572     .Case("POWER7", "pwr7")
 573     .Default(generic);
 574 }
 575 #elif defined(__linux__) && defined(__arm__)
 576 StringRef sys::getHostCPUName() {
 577   // The cpuid register on arm is not accessible from user space. On Linux,
 578   // it is exposed through the /proc/cpuinfo file.
 579   // Note: We cannot mmap /proc/cpuinfo here and then process the resulting
 580   // memory buffer because the 'file' has 0 size (it can be read from only
 581   // as a stream).
 582
 583   std::string Err;
 584   DataStreamer *DS = getDataFileStreamer("/proc/cpuinfo", &Err);
 585   if (!DS) {
 586     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << Err << "\n");
 587     return "generic";
 588   }
 589
 590   // Read 1024 bytes from /proc/cpuinfo, which should contain the CPU part line
 591   // in all cases.
 592   char buffer[1024];
 593   size_t CPUInfoSize = DS->GetBytes((unsigned char*) buffer, sizeof(buffer));
 594   delete DS;
 595
 596   StringRef Str(buffer, CPUInfoSize);
 597
 598   SmallVector<StringRef, 32> Lines;
 599   Str.split(Lines, "\n");
 600
 601   // Look for the CPU implementer line.
 602   StringRef Implementer;
 603   for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 604     if (Lines[I].startswith("CPU implementer"))
 605       Implementer = Lines[I].substr(15).ltrim("\t :");
 606
 607   if (Implementer == "0x41") // ARM Ltd.
 608     // Look for the CPU part line.
 609     for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 610       if (Lines[I].startswith("CPU part"))
 611         // The CPU part is a 3 digit hexadecimal number with a 0x prefix. The
 612         // values correspond to the "Part number" in the CP15/c0 register. The
 613         // contents are specified in the various processor manuals.
 614         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))
 615           .Case("0x926", "arm926ej-s")
 616           .Case("0xb02", "mpcore")
 617           .Case("0xb36", "arm1136j-s")
 618           .Case("0xb56", "arm1156t2-s")
 619           .Case("0xb76", "arm1176jz-s")
 620           .Case("0xc08", "cortex-a8")
 621           .Case("0xc09", "cortex-a9")
 622           .Case("0xc0f", "cortex-a15")
 623           .Case("0xc20", "cortex-m0")
 624           .Case("0xc23", "cortex-m3")
 625           .Case("0xc24", "cortex-m4")
 626           .Default("generic");
 627
 628   if (Implementer == "0x51") // Qualcomm Technologies, Inc.
 629     // Look for the CPU part line.
 630     for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 631       if (Lines[I].startswith("CPU part"))
 632         // The CPU part is a 3 digit hexadecimal number with a 0x prefix. The
 633         // values correspond to the "Part number" in the CP15/c0 register. The
 634         // contents are specified in the various processor manuals.
 635         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))
 636           .Case("0x06f", "krait") // APQ8064
 637           .Default("generic");
 638
 639   return "generic";
 640 }
 641 #elif defined(__linux__) && defined(__s390x__)
 642 StringRef sys::getHostCPUName() {
 643   // STIDP is a privileged operation, so use /proc/cpuinfo instead.
 644   // Note: We cannot mmap /proc/cpuinfo here and then process the resulting
 645   // memory buffer because the 'file' has 0 size (it can be read from only
 646   // as a stream).
 647
 648   std::string Err;
 649   DataStreamer *DS = getDataFileStreamer("/proc/cpuinfo", &Err);
 650   if (!DS) {
 651     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << Err << "\n");
 652     return "generic";
 653   }
 654
 655   // The "processor 0:" line comes after a fair amount of other information,
 656   // including a cache breakdown, but this should be plenty.
 657   char buffer[2048];
 658   size_t CPUInfoSize = DS->GetBytes((unsigned char*) buffer, sizeof(buffer));
 659   delete DS;
 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(__linux__) && defined(__arm__)
 690 bool sys::getHostCPUFeatures(StringMap<bool> &Features) {
 691   std::string Err;
 692   DataStreamer *DS = getDataFileStreamer("/proc/cpuinfo", &Err);
 693   if (!DS) {
 694     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << Err << "\n");
 695     return false;
 696   }
 697
 698   // Read 1024 bytes from /proc/cpuinfo, which should contain the Features line
 699   // in all cases.
 700   char buffer[1024];
 701   size_t CPUInfoSize = DS->GetBytes((unsigned char*) buffer, sizeof(buffer));
 702   delete DS;
 703
 704   StringRef Str(buffer, CPUInfoSize);
 705
 706   SmallVector<StringRef, 32> Lines;
 707   Str.split(Lines, "\n");
 708
 709   SmallVector<StringRef, 32> CPUFeatures;
 710
 711   // Look for the CPU features.
 712   for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 713     if (Lines[I].startswith("Features")) {
 714       Lines[I].split(CPUFeatures, " ");
 715       break;
 716     }
 717
 718   for (unsigned I = 0, E = CPUFeatures.size(); I != E; ++I) {
 719     StringRef LLVMFeatureStr = StringSwitch<StringRef>(CPUFeatures[I])
 720       .Case("half", "fp16")
 721       .Case("neon", "neon")
 722       .Case("vfpv3", "vfp3")
 723       .Case("vfpv3d16", "d16")
 724       .Case("vfpv4", "vfp4")
 725       .Case("idiva", "hwdiv-arm")
 726       .Case("idivt", "hwdiv")
 727       .Default("");
 728
 729     if (LLVMFeatureStr != "")
 730       Features.GetOrCreateValue(LLVMFeatureStr).setValue(true);
 731   }
 732
 733   return true;
 734 }
 735 #else
 736 bool sys::getHostCPUFeatures(StringMap<bool> &Features){
 737   return false;
 738 }
 739 #endif
 740
 741 std::string sys::getProcessTriple() {
 742   Triple PT(Triple::normalize(LLVM_HOST_TRIPLE));
 743
 744   if (sizeof(void *) == 8 && PT.isArch32Bit())
 745     PT = PT.get64BitArchVariant();
 746   if (sizeof(void *) == 4 && PT.isArch64Bit())
 747     PT = PT.get32BitArchVariant();
 748
 749   return PT.str();
 750 }