Fix .cpp files claiming to be header files
[oota-llvm.git] / lib / Support / Host.cpp
1 //===-- Host.cpp - Implement OS Host Concept --------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file implements the operating system Host concept.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/Support/Host.h"
15 #include "llvm/ADT/SmallVector.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/Config/config.h"
20 #include "llvm/Support/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__) || defined(__aarch64__))
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 #if defined(__aarch64__)
719   // Keep track of which crypto features we have seen
720   enum {
721     CAP_AES   = 0x1,
722     CAP_PMULL = 0x2,
723     CAP_SHA1  = 0x4,
724     CAP_SHA2  = 0x8
725   };
726   uint32_t crypto = 0;
727 #endif
728
729   for (unsigned I = 0, E = CPUFeatures.size(); I != E; ++I) {
730     StringRef LLVMFeatureStr = StringSwitch<StringRef>(CPUFeatures[I])
731 #if defined(__aarch64__)
732       .Case("asimd", "neon")
733       .Case("fp", "fp-armv8")
734       .Case("crc32", "crc")
735 #else
736       .Case("half", "fp16")
737       .Case("neon", "neon")
738       .Case("vfpv3", "vfp3")
739       .Case("vfpv3d16", "d16")
740       .Case("vfpv4", "vfp4")
741       .Case("idiva", "hwdiv-arm")
742       .Case("idivt", "hwdiv")
743 #endif
744       .Default("");
745
746 #if defined(__aarch64__)
747     // We need to check crypto separately since we need all of the crypto
748     // extensions to enable the subtarget feature
749     if (CPUFeatures[I] == "aes")
750       crypto |= CAP_AES;
751     else if (CPUFeatures[I] == "pmull")
752       crypto |= CAP_PMULL;
753     else if (CPUFeatures[I] == "sha1")
754       crypto |= CAP_SHA1;
755     else if (CPUFeatures[I] == "sha2")
756       crypto |= CAP_SHA2;
757 #endif
758
759     if (LLVMFeatureStr != "")
760       Features.GetOrCreateValue(LLVMFeatureStr).setValue(true);
761   }
762
763 #if defined(__aarch64__)
764   // If we have all crypto bits we can add the feature
765   if (crypto == (CAP_AES | CAP_PMULL | CAP_SHA1 | CAP_SHA2))
766     Features.GetOrCreateValue("crypto").setValue(true);
767 #endif
768
769   return true;
770 }
771 #else
772 bool sys::getHostCPUFeatures(StringMap<bool> &Features){
773   return false;
774 }
775 #endif
776
777 std::string sys::getProcessTriple() {
778   Triple PT(Triple::normalize(LLVM_HOST_TRIPLE));
779
780   if (sizeof(void *) == 8 && PT.isArch32Bit())
781     PT = PT.get64BitArchVariant();
782   if (sizeof(void *) == 4 && PT.isArch64Bit())
783     PT = PT.get32BitArchVariant();
784
785   return PT.str();
786 }