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 >= 0x30)
 352           return "bdver3"; // 30h-3Fh: Steamroller
 353         if (Model >= 0x10)
 354           return "bdver2"; // 10h-1Fh: Piledriver
 355         return "bdver1";   // 00h-0Fh: Bulldozer
 356       case 22:
 357         if (!HasAVX) // If the OS doesn't support AVX provide a sane fallback.
 358           return "btver1";
 359         return "btver2";
 360     default:
 361       return "generic";
 362     }
 363   }
 364   return "generic";
 365 }
 366 #elif defined(__APPLE__) && (defined(__ppc__) || defined(__powerpc__))
 367 std::string sys::getHostCPUName() {
 368   host_basic_info_data_t hostInfo;
 369   mach_msg_type_number_t infoCount;
 370
 371   infoCount = HOST_BASIC_INFO_COUNT;
 372   host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo,
 373             &infoCount);
 374
 375   if (hostInfo.cpu_type != CPU_TYPE_POWERPC) return "generic";
 376
 377   switch(hostInfo.cpu_subtype) {
 378   case CPU_SUBTYPE_POWERPC_601:   return "601";
 379   case CPU_SUBTYPE_POWERPC_602:   return "602";
 380   case CPU_SUBTYPE_POWERPC_603:   return "603";
 381   case CPU_SUBTYPE_POWERPC_603e:  return "603e";
 382   case CPU_SUBTYPE_POWERPC_603ev: return "603ev";
 383   case CPU_SUBTYPE_POWERPC_604:   return "604";
 384   case CPU_SUBTYPE_POWERPC_604e:  return "604e";
 385   case CPU_SUBTYPE_POWERPC_620:   return "620";
 386   case CPU_SUBTYPE_POWERPC_750:   return "750";
 387   case CPU_SUBTYPE_POWERPC_7400:  return "7400";
 388   case CPU_SUBTYPE_POWERPC_7450:  return "7450";
 389   case CPU_SUBTYPE_POWERPC_970:   return "970";
 390   default: ;
 391   }
 392
 393   return "generic";
 394 }
 395 #elif defined(__linux__) && (defined(__ppc__) || defined(__powerpc__))
 396 std::string sys::getHostCPUName() {
 397   // Access to the Processor Version Register (PVR) on PowerPC is privileged,
 398   // and so we must use an operating-system interface to determine the current
 399   // processor type. On Linux, this is exposed through the /proc/cpuinfo file.
 400   const char *generic = "generic";
 401
 402   // Note: We cannot mmap /proc/cpuinfo here and then process the resulting
 403   // memory buffer because the 'file' has 0 size (it can be read from only
 404   // as a stream).
 405
 406   std::string Err;
 407   DataStreamer *DS = getDataFileStreamer("/proc/cpuinfo", &Err);
 408   if (!DS) {
 409     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << Err << "\n");
 410     return generic;
 411   }
 412
 413   // The cpu line is second (after the 'processor: 0' line), so if this
 414   // buffer is too small then something has changed (or is wrong).
 415   char buffer[1024];
 416   size_t CPUInfoSize = DS->GetBytes((unsigned char*) buffer, sizeof(buffer));
 417   delete DS;
 418
 419   const char *CPUInfoStart = buffer;
 420   const char *CPUInfoEnd = buffer + CPUInfoSize;
 421
 422   const char *CIP = CPUInfoStart;
 423
 424   const char *CPUStart = 0;
 425   size_t CPULen = 0;
 426
 427   // We need to find the first line which starts with cpu, spaces, and a colon.
 428   // After the colon, there may be some additional spaces and then the cpu type.
 429   while (CIP < CPUInfoEnd && CPUStart == 0) {
 430     if (CIP < CPUInfoEnd && *CIP == '\n')
 431       ++CIP;
 432
 433     if (CIP < CPUInfoEnd && *CIP == 'c') {
 434       ++CIP;
 435       if (CIP < CPUInfoEnd && *CIP == 'p') {
 436         ++CIP;
 437         if (CIP < CPUInfoEnd && *CIP == 'u') {
 438           ++CIP;
 439           while (CIP < CPUInfoEnd && (*CIP == ' ' || *CIP == '\t'))
 440             ++CIP;
 441
 442           if (CIP < CPUInfoEnd && *CIP == ':') {
 443             ++CIP;
 444             while (CIP < CPUInfoEnd && (*CIP == ' ' || *CIP == '\t'))
 445               ++CIP;
 446
 447             if (CIP < CPUInfoEnd) {
 448               CPUStart = CIP;
 449               while (CIP < CPUInfoEnd && (*CIP != ' ' && *CIP != '\t' &&
 450                                           *CIP != ',' && *CIP != '\n'))
 451                 ++CIP;
 452               CPULen = CIP - CPUStart;
 453             }
 454           }
 455         }
 456       }
 457     }
 458
 459     if (CPUStart == 0)
 460       while (CIP < CPUInfoEnd && *CIP != '\n')
 461         ++CIP;
 462   }
 463
 464   if (CPUStart == 0)
 465     return generic;
 466
 467   return StringSwitch<const char *>(StringRef(CPUStart, CPULen))
 468     .Case("604e", "604e")
 469     .Case("604", "604")
 470     .Case("7400", "7400")
 471     .Case("7410", "7400")
 472     .Case("7447", "7400")
 473     .Case("7455", "7450")
 474     .Case("G4", "g4")
 475     .Case("POWER4", "970")
 476     .Case("PPC970FX", "970")
 477     .Case("PPC970MP", "970")
 478     .Case("G5", "g5")
 479     .Case("POWER5", "g5")
 480     .Case("A2", "a2")
 481     .Case("POWER6", "pwr6")
 482     .Case("POWER7", "pwr7")
 483     .Default(generic);
 484 }
 485 #elif defined(__linux__) && defined(__arm__)
 486 std::string sys::getHostCPUName() {
 487   // The cpuid register on arm is not accessible from user space. On Linux,
 488   // it is exposed through the /proc/cpuinfo file.
 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   // Read 1024 bytes from /proc/cpuinfo, which should contain the CPU part line
 501   // in all cases.
 502   char buffer[1024];
 503   size_t CPUInfoSize = DS->GetBytes((unsigned char*) buffer, sizeof(buffer));
 504   delete DS;
 505
 506   StringRef Str(buffer, CPUInfoSize);
 507
 508   SmallVector<StringRef, 32> Lines;
 509   Str.split(Lines, "\n");
 510
 511   // Look for the CPU implementer line.
 512   StringRef Implementer;
 513   for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 514     if (Lines[I].startswith("CPU implementer"))
 515       Implementer = Lines[I].substr(15).ltrim("\t :");
 516
 517   if (Implementer == "0x41") // ARM Ltd.
 518     // Look for the CPU part line.
 519     for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 520       if (Lines[I].startswith("CPU part"))
 521         // The CPU part is a 3 digit hexadecimal number with a 0x prefix. The
 522         // values correspond to the "Part number" in the CP15/c0 register. The
 523         // contents are specified in the various processor manuals.
 524         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))
 525           .Case("0x926", "arm926ej-s")
 526           .Case("0xb02", "mpcore")
 527           .Case("0xb36", "arm1136j-s")
 528           .Case("0xb56", "arm1156t2-s")
 529           .Case("0xb76", "arm1176jz-s")
 530           .Case("0xc08", "cortex-a8")
 531           .Case("0xc09", "cortex-a9")
 532           .Case("0xc0f", "cortex-a15")
 533           .Case("0xc20", "cortex-m0")
 534           .Case("0xc23", "cortex-m3")
 535           .Case("0xc24", "cortex-m4")
 536           .Default("generic");
 537
 538   return "generic";
 539 }
 540 #elif defined(__linux__) && defined(__s390x__)
 541 std::string sys::getHostCPUName() {
 542   // STIDP is a privileged operation, so use /proc/cpuinfo instead.
 543   // Note: We cannot mmap /proc/cpuinfo here and then process the resulting
 544   // memory buffer because the 'file' has 0 size (it can be read from only
 545   // as a stream).
 546
 547   std::string Err;
 548   DataStreamer *DS = getDataFileStreamer("/proc/cpuinfo", &Err);
 549   if (!DS) {
 550     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << Err << "\n");
 551     return "generic";
 552   }
 553
 554   // The "processor 0:" line comes after a fair amount of other information,
 555   // including a cache breakdown, but this should be plenty.
 556   char buffer[2048];
 557   size_t CPUInfoSize = DS->GetBytes((unsigned char*) buffer, sizeof(buffer));
 558   delete DS;
 559
 560   StringRef Str(buffer, CPUInfoSize);
 561   SmallVector<StringRef, 32> Lines;
 562   Str.split(Lines, "\n");
 563   for (unsigned I = 0, E = Lines.size(); I != E; ++I) {
 564     if (Lines[I].startswith("processor ")) {
 565       size_t Pos = Lines[I].find("machine = ");
 566       if (Pos != StringRef::npos) {
 567         Pos += sizeof("machine = ") - 1;
 568         unsigned int Id;
 569         if (!Lines[I].drop_front(Pos).getAsInteger(10, Id)) {
 570           if (Id >= 2827)
 571             return "zEC12";
 572           if (Id >= 2817)
 573             return "z196";
 574         }
 575       }
 576       break;
 577     }
 578   }
 579
 580   return "generic";
 581 }
 582 #else
 583 std::string sys::getHostCPUName() {
 584   return "generic";
 585 }
 586 #endif
 587
 588 #if defined(__linux__) && defined(__arm__)
 589 bool sys::getHostCPUFeatures(StringMap<bool> &Features) {
 590   std::string Err;
 591   DataStreamer *DS = getDataFileStreamer("/proc/cpuinfo", &Err);
 592   if (!DS) {
 593     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << Err << "\n");
 594     return false;
 595   }
 596
 597   // Read 1024 bytes from /proc/cpuinfo, which should contain the Features line
 598   // in all cases.
 599   char buffer[1024];
 600   size_t CPUInfoSize = DS->GetBytes((unsigned char*) buffer, sizeof(buffer));
 601   delete DS;
 602
 603   StringRef Str(buffer, CPUInfoSize);
 604
 605   SmallVector<StringRef, 32> Lines;
 606   Str.split(Lines, "\n");
 607
 608   SmallVector<StringRef, 32> CPUFeatures;
 609
 610   // Look for the CPU features.
 611   for (unsigned I = 0, E = Lines.size(); I != E; ++I)
 612     if (Lines[I].startswith("Features")) {
 613       Lines[I].split(CPUFeatures, " ");
 614       break;
 615     }
 616
 617   for (unsigned I = 0, E = CPUFeatures.size(); I != E; ++I) {
 618     StringRef LLVMFeatureStr = StringSwitch<StringRef>(CPUFeatures[I])
 619       .Case("half", "fp16")
 620       .Case("neon", "neon")
 621       .Case("vfpv3", "vfp3")
 622       .Case("vfpv3d16", "d16")
 623       .Case("vfpv4", "vfp4")
 624       .Case("idiva", "hwdiv-arm")
 625       .Case("idivt", "hwdiv")
 626       .Default("");
 627
 628     if (LLVMFeatureStr != "")
 629       Features.GetOrCreateValue(LLVMFeatureStr).setValue(true);
 630   }
 631
 632   return true;
 633 }
 634 #else
 635 bool sys::getHostCPUFeatures(StringMap<bool> &Features){
 636   return false;
 637 }
 638 #endif
 639
 640 std::string sys::getProcessTriple() {
 641   Triple PT(Triple::normalize(LLVM_HOST_TRIPLE));
 642
 643   if (sizeof(void *) == 8 && PT.isArch32Bit())
 644     PT = PT.get64BitArchVariant();
 645   if (sizeof(void *) == 4 && PT.isArch64Bit())
 646     PT = PT.get32BitArchVariant();
 647
 648   return PT.str();
 649 }