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