LLVM 23.0.0git
Host.cpp
Go to the documentation of this file.
1//===-- Host.cpp - Implement OS Host Detection ------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the operating system Host detection.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/TargetParser/Host.h"
14#include "llvm/ADT/Bitfields.h"
15#include "llvm/ADT/STLFunctionalExtras.h"
16#include "llvm/ADT/SmallVector.h"
17#include "llvm/ADT/StringExtras.h"
18#include "llvm/ADT/StringMap.h"
19#include "llvm/ADT/StringRef.h"
20#include "llvm/ADT/StringSwitch.h"
21#include "llvm/Config/llvm-config.h"
22#include "llvm/Support/MemoryBuffer.h"
23#include "llvm/Support/raw_ostream.h"
24#include "llvm/TargetParser/RISCVTargetParser.h"
25#include "llvm/TargetParser/Triple.h"
26#include "llvm/TargetParser/X86TargetParser.h"
27#include <string.h>
28
29// Include the platform-specific parts of this class.
30#ifdef LLVM_ON_UNIX
31#include "Unix/Host.inc"
32#include <sched.h>
33#endif
34#ifdef _WIN32
35#include "Windows/Host.inc"
36#endif
37#ifdef _MSC_VER
38#include <intrin.h>
39#endif
40#ifdef __MVS__
41#include "llvm/Support/BCD.h"
42#endif
43#if defined(__APPLE__)
44#include <mach/host_info.h>
45#include <mach/mach.h>
46#include <mach/mach_host.h>
47#include <mach/machine.h>
48#include <sys/param.h>
49#include <sys/sysctl.h>
50#endif
51#ifdef _AIX
52#include <sys/systemcfg.h>
53#endif
54#if defined(__sun__) && defined(__svr4__)
55#include <kstat.h>
56#endif
57#if defined(__GNUC__) || defined(__clang__)
58#if (defined(__i386__) || defined(__x86_64__)) && !defined(_MSC_VER)
59#include <cpuid.h>
60#endif
61#endif
62
63#define DEBUG_TYPE "host-detection"
64
65//===----------------------------------------------------------------------===//
66//
67// Implementations of the CPU detection routines
68//
69//===----------------------------------------------------------------------===//
70
71using namespace llvm;
72
73[[maybe_unused]] static std::unique_ptr<llvm::MemoryBuffer>
74getProcCpuinfoContent() {
75 const char *CPUInfoFile = "/proc/cpuinfo";
76 if (const char *CpuinfoIntercept = std::getenv("LLVM_CPUINFO"))
77 CPUInfoFile = CpuinfoIntercept;
78 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
79 llvm::MemoryBuffer::getFileAsStream(CPUInfoFile);
80
81 if (std::error_code EC = Text.getError()) {
82 llvm::errs() << "Can't read " << CPUInfoFile << ": " << EC.message()
83 << "\n";
84 return nullptr;
85 }
86 return std::move(*Text);
87}
88
89StringRef sys::detail::getHostCPUNameForPowerPC(StringRef ProcCpuinfoContent) {
90 // Access to the Processor Version Register (PVR) on PowerPC is privileged,
91 // and so we must use an operating-system interface to determine the current
92 // processor type. On Linux, this is exposed through the /proc/cpuinfo file.
93 const char *generic = "generic";
94
95 // The cpu line is second (after the 'processor: 0' line), so if this
96 // buffer is too small then something has changed (or is wrong).
97 StringRef::const_iterator CPUInfoStart = ProcCpuinfoContent.begin();
98 StringRef::const_iterator CPUInfoEnd = ProcCpuinfoContent.end();
99
100 StringRef::const_iterator CIP = CPUInfoStart;
101
102 StringRef::const_iterator CPUStart = nullptr;
103 size_t CPULen = 0;
104
105 // We need to find the first line which starts with cpu, spaces, and a colon.
106 // After the colon, there may be some additional spaces and then the cpu type.
107 while (CIP < CPUInfoEnd && CPUStart == nullptr) {
108 if (CIP < CPUInfoEnd && *CIP == '\n')
109 ++CIP;
110
111 if (CIP < CPUInfoEnd && *CIP == 'c') {
112 ++CIP;
113 if (CIP < CPUInfoEnd && *CIP == 'p') {
114 ++CIP;
115 if (CIP < CPUInfoEnd && *CIP == 'u') {
116 ++CIP;
117 while (CIP < CPUInfoEnd && (*CIP == ' ' || *CIP == '\t'))
118 ++CIP;
119
120 if (CIP < CPUInfoEnd && *CIP == ':') {
121 ++CIP;
122 while (CIP < CPUInfoEnd && (*CIP == ' ' || *CIP == '\t'))
123 ++CIP;
124
125 if (CIP < CPUInfoEnd) {
126 CPUStart = CIP;
127 while (CIP < CPUInfoEnd && (*CIP != ' ' && *CIP != '\t' &&
128 *CIP != ',' && *CIP != '\n'))
129 ++CIP;
130 CPULen = CIP - CPUStart;
131 }
132 }
133 }
134 }
135 }
136
137 if (CPUStart == nullptr)
138 while (CIP < CPUInfoEnd && *CIP != '\n')
139 ++CIP;
140 }
141
142 if (CPUStart == nullptr)
143 return generic;
144
145 return StringSwitch<const char *>(StringRef(CPUStart, CPULen))
146 .Case("604e", "604e")
147 .Case("604", "604")
148 .Case("7400", "7400")
149 .Case("7410", "7400")
150 .Case("7447", "7400")
151 .Case("7455", "7450")
152 .Case("G4", "g4")
153 .Case("POWER4", "970")
154 .Case("PPC970FX", "970")
155 .Case("PPC970MP", "970")
156 .Case("G5", "g5")
157 .Case("POWER5", "g5")
158 .Case("A2", "a2")
159 .Case("POWER6", "pwr6")
160 .Case("POWER7", "pwr7")
161 .Case("POWER8", "pwr8")
162 .Case("POWER8E", "pwr8")
163 .Case("POWER8NVL", "pwr8")
164 .Case("POWER9", "pwr9")
165 .Case("POWER10", "pwr10")
166 .Case("POWER11", "pwr11")
167 // FIXME: If we get a simulator or machine with the capabilities of
168 // mcpu=future, we should revisit this and add the name reported by the
169 // simulator/machine.
170 .Default(generic);
171}
172
173StringRef
174getHostCPUNameForARMFromComponents(StringRef Implementer, StringRef Hardware,
175 StringRef Part, ArrayRef<StringRef> Parts,
176 function_ref<unsigned()> GetVariant) {
177
178 auto MatchBigLittle = [](auto const &Parts, StringRef Big, StringRef Little) {
179 if (Parts.size() == 2)
180 return (Parts[0] == Big && Parts[1] == Little) ||
181 (Parts[1] == Big && Parts[0] == Little);
182 return false;
183 };
184
185 if (Implementer == "0x41") { // ARM Ltd.
186 // MSM8992/8994 may give cpu part for the core that the kernel is running on,
187 // which is undeterministic and wrong. Always return cortex-a53 for these SoC.
188 if (Hardware.ends_with("MSM8994") || Hardware.ends_with("MSM8996"))
189 return "cortex-a53";
190
191 // Detect big.LITTLE systems.
192 if (MatchBigLittle(Parts, "0xd85", "0xd87"))
193 return "cortex-x925";
194
195 // The CPU part is a 3 digit hexadecimal number with a 0x prefix. The
196 // values correspond to the "Part number" in the CP15/c0 register. The
197 // contents are specified in the various processor manuals.
198 // This corresponds to the Main ID Register in Technical Reference Manuals.
199 // and is used in programs like sys-utils
200 return StringSwitch<const char *>(Part)
201 .Case("0x926", "arm926ej-s")
202 .Case("0xb02", "mpcore")
203 .Case("0xb36", "arm1136j-s")
204 .Case("0xb56", "arm1156t2-s")
205 .Case("0xb76", "arm1176jz-s")
206 .Case("0xd8a", "c1-nano")
207 .Case("0xd90", "c1-premium")
208 .Case("0xd8b", "c1-pro")
209 .Case("0xd8c", "c1-ultra")
210 .Case("0xc05", "cortex-a5")
211 .Case("0xc07", "cortex-a7")
212 .Case("0xc08", "cortex-a8")
213 .Case("0xc09", "cortex-a9")
214 .Case("0xc0f", "cortex-a15")
215 .Case("0xc0e", "cortex-a17")
216 .Case("0xc20", "cortex-m0")
217 .Case("0xc23", "cortex-m3")
218 .Case("0xc24", "cortex-m4")
219 .Case("0xc27", "cortex-m7")
220 .Case("0xd20", "cortex-m23")
221 .Case("0xd21", "cortex-m33")
222 .Case("0xd24", "cortex-m52")
223 .Case("0xd22", "cortex-m55")
224 .Case("0xd23", "cortex-m85")
225 .Case("0xc18", "cortex-r8")
226 .Case("0xd13", "cortex-r52")
227 .Case("0xd16", "cortex-r52plus")
228 .Case("0xd15", "cortex-r82")
229 .Case("0xd14", "cortex-r82ae")
230 .Case("0xd02", "cortex-a34")
231 .Case("0xd04", "cortex-a35")
232 .Case("0xd8f", "cortex-a320")
233 .Case("0xd03", "cortex-a53")
234 .Case("0xd05", "cortex-a55")
235 .Case("0xd46", "cortex-a510")
236 .Case("0xd80", "cortex-a520")
237 .Case("0xd88", "cortex-a520ae")
238 .Case("0xd07", "cortex-a57")
239 .Case("0xd06", "cortex-a65")
240 .Case("0xd43", "cortex-a65ae")
241 .Case("0xd08", "cortex-a72")
242 .Case("0xd09", "cortex-a73")
243 .Case("0xd0a", "cortex-a75")
244 .Case("0xd0b", "cortex-a76")
245 .Case("0xd0e", "cortex-a76ae")
246 .Case("0xd0d", "cortex-a77")
247 .Case("0xd41", "cortex-a78")
248 .Case("0xd42", "cortex-a78ae")
249 .Case("0xd4b", "cortex-a78c")
250 .Case("0xd47", "cortex-a710")
251 .Case("0xd4d", "cortex-a715")
252 .Case("0xd81", "cortex-a720")
253 .Case("0xd89", "cortex-a720ae")
254 .Case("0xd87", "cortex-a725")
255 .Case("0xd44", "cortex-x1")
256 .Case("0xd4c", "cortex-x1c")
257 .Case("0xd48", "cortex-x2")
258 .Case("0xd4e", "cortex-x3")
259 .Case("0xd82", "cortex-x4")
260 .Case("0xd85", "cortex-x925")
261 .Case("0xd4a", "neoverse-e1")
262 .Case("0xd0c", "neoverse-n1")
263 .Case("0xd49", "neoverse-n2")
264 .Case("0xd8e", "neoverse-n3")
265 .Case("0xd40", "neoverse-v1")
266 .Case("0xd4f", "neoverse-v2")
267 .Case("0xd84", "neoverse-v3")
268 .Case("0xd83", "neoverse-v3ae")
269 .Default("generic");
270 }
271
272 if (Implementer == "0x42" || Implementer == "0x43") { // Broadcom | Cavium.
273 return StringSwitch<const char *>(Part)
274 .Case("0x516", "thunderx2t99")
275 .Case("0x0516", "thunderx2t99")
276 .Case("0xaf", "thunderx2t99")
277 .Case("0x0af", "thunderx2t99")
278 .Case("0xa1", "thunderxt88")
279 .Case("0x0a1", "thunderxt88")
280 .Default("generic");
281 }
282
283 if (Implementer == "0x46") { // Fujitsu Ltd.
284 return StringSwitch<const char *>(Part)
285 .Case("0x001", "a64fx")
286 .Case("0x003", "fujitsu-monaka")
287 .Default("generic");
288 }
289
290 if (Implementer == "0x4e") { // NVIDIA Corporation
291 return StringSwitch<const char *>(Part)
292 .Case("0x004", "carmel")
293 .Case("0x10", "olympus")
294 .Case("0x010", "olympus")
295 .Default("generic");
296 }
297
298 if (Implementer == "0x48") // HiSilicon Technologies, Inc.
299 // The CPU part is a 3 digit hexadecimal number with a 0x prefix. The
300 // values correspond to the "Part number" in the CP15/c0 register. The
301 // contents are specified in the various processor manuals.
302 return StringSwitch<const char *>(Part)
303 .Case("0xd01", "tsv110")
304 .Default("generic");
305
306 if (Implementer == "0x51") // Qualcomm Technologies, Inc.
307 // The CPU part is a 3 digit hexadecimal number with a 0x prefix. The
308 // values correspond to the "Part number" in the CP15/c0 register. The
309 // contents are specified in the various processor manuals.
310 return StringSwitch<const char *>(Part)
311 .Case("0x06f", "krait") // APQ8064
312 .Case("0x201", "kryo")
313 .Case("0x205", "kryo")
314 .Case("0x211", "kryo")
315 .Case("0x800", "cortex-a73") // Kryo 2xx Gold
316 .Case("0x801", "cortex-a73") // Kryo 2xx Silver
317 .Case("0x802", "cortex-a75") // Kryo 3xx Gold
318 .Case("0x803", "cortex-a75") // Kryo 3xx Silver
319 .Case("0x804", "cortex-a76") // Kryo 4xx Gold
320 .Case("0x805", "cortex-a76") // Kryo 4xx/5xx Silver
321 .Case("0xc00", "falkor")
322 .Case("0xc01", "saphira")
323 .Case("0x001", "oryon-1")
324 .Default("generic");
325 if (Implementer == "0x53") { // Samsung Electronics Co., Ltd.
326 // The Exynos chips have a convoluted ID scheme that doesn't seem to follow
327 // any predictive pattern across variants and parts.
328
329 // Look for the CPU variant line, whose value is a 1 digit hexadecimal
330 // number, corresponding to the Variant bits in the CP15/C0 register.
331 unsigned Variant = GetVariant();
332
333 // Convert the CPU part line, whose value is a 3 digit hexadecimal number,
334 // corresponding to the PartNum bits in the CP15/C0 register.
335 unsigned PartAsInt;
336 Part.getAsInteger(0, PartAsInt);
337
338 unsigned Exynos = (Variant << 12) | PartAsInt;
339 switch (Exynos) {
340 default:
341 // Default by falling through to Exynos M3.
342 [[fallthrough]];
343 case 0x1002:
344 return "exynos-m3";
345 case 0x1003:
346 return "exynos-m4";
347 }
348 }
349
350 if (Implementer == "0x61") { // Apple
351 return StringSwitch<const char *>(Part)
352 .Case("0x020", "apple-m1")
353 .Case("0x021", "apple-m1")
354 .Case("0x022", "apple-m1")
355 .Case("0x023", "apple-m1")
356 .Case("0x024", "apple-m1")
357 .Case("0x025", "apple-m1")
358 .Case("0x028", "apple-m1")
359 .Case("0x029", "apple-m1")
360 .Case("0x030", "apple-m2")
361 .Case("0x031", "apple-m2")
362 .Case("0x032", "apple-m2")
363 .Case("0x033", "apple-m2")
364 .Case("0x034", "apple-m2")
365 .Case("0x035", "apple-m2")
366 .Case("0x038", "apple-m2")
367 .Case("0x039", "apple-m2")
368 .Case("0x049", "apple-m3")
369 .Case("0x048", "apple-m3")
370 .Default("generic");
371 }
372
373 if (Implementer == "0x63") { // Arm China.
374 return StringSwitch<const char *>(Part)
375 .Case("0x132", "star-mc1")
376 .Case("0xd25", "star-mc3")
377 .Default("generic");
378 }
379
380 if (Implementer == "0x6d") { // Microsoft Corporation.
381 // The Microsoft Azure Cobalt 100 CPU is handled as a Neoverse N2.
382 return StringSwitch<const char *>(Part)
383 .Case("0xd49", "neoverse-n2")
384 .Default("generic");
385 }
386
387 if (Implementer == "0xc0") { // Ampere Computing
388 return StringSwitch<const char *>(Part)
389 .Case("0xac3", "ampere1")
390 .Case("0xac4", "ampere1a")
391 .Case("0xac5", "ampere1b")
392 .Case("0xac7", "ampere1c")
393 .Default("generic");
394 }
395
396 return "generic";
397}
398
399StringRef sys::detail::getHostCPUNameForARM(StringRef ProcCpuinfoContent) {
400 // The cpuid register on arm is not accessible from user space. On Linux,
401 // it is exposed through the /proc/cpuinfo file.
402
403 // Read 32 lines from /proc/cpuinfo, which should contain the CPU part line
404 // in all cases.
405 SmallVector<StringRef, 32> Lines;
406 ProcCpuinfoContent.split(Lines, '\n');
407
408 // Look for the CPU implementer and hardware lines, and store the CPU part
409 // numbers found.
410 StringRef Implementer;
411 StringRef Hardware;
412 SmallVector<StringRef, 32> Parts;
413 for (StringRef Line : Lines) {
414 if (Line.consume_front("CPU implementer"))
415 Implementer = Line.ltrim("\t :");
416 else if (Line.consume_front("Hardware"))
417 Hardware = Line.ltrim("\t :");
418 else if (Line.consume_front("CPU part"))
419 Parts.emplace_back(Line.ltrim("\t :"));
420 }
421
422 // Last `Part' seen, in case we don't analyse all `Parts' parsed.
423 StringRef Part = Parts.empty() ? StringRef() : Parts.back();
424
425 // Remove duplicate `Parts'.
426 llvm::sort(Parts);
427 Parts.erase(llvm::unique(Parts), Parts.end());
428
429 auto GetVariant = [&]() {
430 unsigned Variant = 0;
431 for (auto I : Lines)
432 if (I.consume_front("CPU variant"))
433 I.ltrim("\t :").getAsInteger(0, Variant);
434 return Variant;
435 };
436
437 return getHostCPUNameForARMFromComponents(Implementer, Hardware, Part, Parts,
438 GetVariant);
439}
440
441StringRef sys::detail::getHostCPUNameForARM(uint64_t PrimaryCpuInfo,
442 ArrayRef<uint64_t> UniqueCpuInfos) {
443 // On Windows, the registry provides cached copied of the MIDR_EL1 register.
444 using PartNum = Bitfield::Element<uint16_t, 4, 12>;
445 using Implementer = Bitfield::Element<uint16_t, 24, 8>;
446 using Variant = Bitfield::Element<uint16_t, 20, 4>;
447
448 SmallVector<std::string> PartsHolder;
449 PartsHolder.reserve(UniqueCpuInfos.size());
450 for (auto Info : UniqueCpuInfos)
451 PartsHolder.push_back("0x" + utohexstr(Bitfield::get<PartNum>(Info),
452 /*LowerCase*/ true,
453 /*Width*/ 3));
454
455 SmallVector<StringRef> Parts;
456 Parts.reserve(PartsHolder.size());
457 for (const auto &Part : PartsHolder)
458 Parts.push_back(Part);
459
460 return getHostCPUNameForARMFromComponents(
461 "0x" + utohexstr(Bitfield::get<Implementer>(PrimaryCpuInfo),
462 /*LowerCase*/ true,
463 /*Width*/ 2),
464 /*Hardware*/ "",
465 "0x" + utohexstr(Bitfield::get<PartNum>(PrimaryCpuInfo),
466 /*LowerCase*/ true,
467 /*Width*/ 3),
468 Parts, [=]() { return Bitfield::get<Variant>(PrimaryCpuInfo); });
469}
470
471namespace {
472StringRef getCPUNameFromS390Model(unsigned int Id, bool HaveVectorSupport) {
473 switch (Id) {
474 case 2064: // z900 not supported by LLVM
475 case 2066:
476 case 2084: // z990 not supported by LLVM
477 case 2086:
478 case 2094: // z9-109 not supported by LLVM
479 case 2096:
480 return "generic";
481 case 2097:
482 case 2098:
483 return "z10";
484 case 2817:
485 case 2818:
486 return "z196";
487 case 2827:
488 case 2828:
489 return "zEC12";
490 case 2964:
491 case 2965:
492 return HaveVectorSupport? "z13" : "zEC12";
493 case 3906:
494 case 3907:
495 return HaveVectorSupport? "z14" : "zEC12";
496 case 8561:
497 case 8562:
498 return HaveVectorSupport? "z15" : "zEC12";
499 case 3931:
500 case 3932:
501 return HaveVectorSupport? "z16" : "zEC12";
502 case 9175:
503 case 9176:
504 default:
505 return HaveVectorSupport? "z17" : "zEC12";
506 }
507}
508} // end anonymous namespace
509
510StringRef sys::detail::getHostCPUNameForS390x(StringRef ProcCpuinfoContent) {
511 // STIDP is a privileged operation, so use /proc/cpuinfo instead.
512
513 // The "processor 0:" line comes after a fair amount of other information,
514 // including a cache breakdown, but this should be plenty.
515 SmallVector<StringRef, 32> Lines;
516 ProcCpuinfoContent.split(Lines, '\n');
517
518 // Look for the CPU features.
519 SmallVector<StringRef, 32> CPUFeatures;
520 for (StringRef Line : Lines)
521 if (Line.starts_with("features")) {
522 size_t Pos = Line.find(':');
523 if (Pos != StringRef::npos) {
524 Line.drop_front(Pos + 1).split(CPUFeatures, ' ');
525 break;
526 }
527 }
528
529 // We need to check for the presence of vector support independently of
530 // the machine type, since we may only use the vector register set when
531 // supported by the kernel (and hypervisor).
532 bool HaveVectorSupport = llvm::is_contained(CPUFeatures, "vx");
533
534 // Now check the processor machine type.
535 for (StringRef Line : Lines) {
536 if (Line.starts_with("processor ")) {
537 size_t Pos = Line.find("machine = ");
538 if (Pos != StringRef::npos) {
539 Pos += sizeof("machine = ") - 1;
540 unsigned int Id;
541 if (!Line.drop_front(Pos).getAsInteger(10, Id))
542 return getCPUNameFromS390Model(Id, HaveVectorSupport);
543 }
544 break;
545 }
546 }
547
548 return "generic";
549}
550
551StringRef sys::detail::getHostCPUNameForRISCV(StringRef ProcCpuinfoContent) {
552 // There are 24 lines in /proc/cpuinfo
553 SmallVector<StringRef> Lines;
554 ProcCpuinfoContent.split(Lines, '\n');
555
556 // Look for uarch line to determine cpu name
557 StringRef UArch;
558 for (StringRef Line : Lines) {
559 if (Line.starts_with("uarch")) {
560 UArch = Line.substr(5).ltrim("\t :");
561 break;
562 }
563 }
564
565 return StringSwitch<const char *>(UArch)
566 .Case("eswin,eic770x", "sifive-p550")
567 .Case("sifive,u74-mc", "sifive-u74")
568 .Case("sifive,bullet0", "sifive-u74")
569 .Default("");
570}
571
572StringRef sys::detail::getHostCPUNameForBPF() {
573#if !defined(__linux__) || !defined(__x86_64__)
574 return "generic";
575#else
576 uint8_t v3_insns[40] __attribute__ ((aligned (8))) =
577 /* BPF_MOV64_IMM(BPF_REG_0, 0) */
578 { 0xb7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
579 /* BPF_MOV64_IMM(BPF_REG_2, 1) */
580 0xb7, 0x2, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0,
581 /* BPF_JMP32_REG(BPF_JLT, BPF_REG_0, BPF_REG_2, 1) */
582 0xae, 0x20, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
583 /* BPF_MOV64_IMM(BPF_REG_0, 1) */
584 0xb7, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0,
585 /* BPF_EXIT_INSN() */
586 0x95, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
587
588 uint8_t v2_insns[40] __attribute__ ((aligned (8))) =
589 /* BPF_MOV64_IMM(BPF_REG_0, 0) */
590 { 0xb7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
591 /* BPF_MOV64_IMM(BPF_REG_2, 1) */
592 0xb7, 0x2, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0,
593 /* BPF_JMP_REG(BPF_JLT, BPF_REG_0, BPF_REG_2, 1) */
594 0xad, 0x20, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
595 /* BPF_MOV64_IMM(BPF_REG_0, 1) */
596 0xb7, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0,
597 /* BPF_EXIT_INSN() */
598 0x95, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
599
600 struct bpf_prog_load_attr {
601 uint32_t prog_type;
602 uint32_t insn_cnt;
603 uint64_t insns;
604 uint64_t license;
605 uint32_t log_level;
606 uint32_t log_size;
607 uint64_t log_buf;
608 uint32_t kern_version;
609 uint32_t prog_flags;
610 } attr = {};
611 attr.prog_type = 1; /* BPF_PROG_TYPE_SOCKET_FILTER */
612 attr.insn_cnt = 5;
613 attr.insns = (uint64_t)v3_insns;
614 attr.license = (uint64_t)"DUMMY";
615
616 int fd = syscall(321 /* __NR_bpf */, 5 /* BPF_PROG_LOAD */, &attr,
617 sizeof(attr));
618 if (fd >= 0) {
619 close(fd);
620 return "v3";
621 }
622
623 /* Clear the whole attr in case its content changed by syscall. */
624 memset(&attr, 0, sizeof(attr));
625 attr.prog_type = 1; /* BPF_PROG_TYPE_SOCKET_FILTER */
626 attr.insn_cnt = 5;
627 attr.insns = (uint64_t)v2_insns;
628 attr.license = (uint64_t)"DUMMY";
629 fd = syscall(321 /* __NR_bpf */, 5 /* BPF_PROG_LOAD */, &attr, sizeof(attr));
630 if (fd >= 0) {
631 close(fd);
632 return "v2";
633 }
634 return "v1";
635#endif
636}
637
638#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || \
639 defined(_M_X64)) && \
640 !defined(_M_ARM64EC)
641
642/// getX86CpuIDAndInfo - Execute the specified cpuid and return the 4 values in
643/// the specified arguments. If we can't run cpuid on the host, return true.
644static bool getX86CpuIDAndInfo(unsigned value, unsigned *rEAX, unsigned *rEBX,
645 unsigned *rECX, unsigned *rEDX) {
646#if (defined(__i386__) || defined(__x86_64__)) && !defined(_MSC_VER)
647 return !__get_cpuid(value, rEAX, rEBX, rECX, rEDX);
648#elif defined(_MSC_VER)
649 // The MSVC intrinsic is portable across x86 and x64.
650 int registers[4];
651 __cpuid(registers, value);
652 *rEAX = registers[0];
653 *rEBX = registers[1];
654 *rECX = registers[2];
655 *rEDX = registers[3];
656 return false;
657#else
658 return true;
659#endif
660}
661
662namespace llvm {
663namespace sys {
664namespace detail {
665namespace x86 {
666
667VendorSignatures getVendorSignature(unsigned *MaxLeaf) {
668 unsigned EAX = 0, EBX = 0, ECX = 0, EDX = 0;
669 if (MaxLeaf == nullptr)
670 MaxLeaf = &EAX;
671 else
672 *MaxLeaf = 0;
673
674 if (getX86CpuIDAndInfo(0, MaxLeaf, &EBX, &ECX, &EDX) || *MaxLeaf < 1)
675 return VendorSignatures::UNKNOWN;
676
677 // "Genu ineI ntel"
678 if (EBX == 0x756e6547 && EDX == 0x49656e69 && ECX == 0x6c65746e)
679 return VendorSignatures::GENUINE_INTEL;
680
681 // "Auth enti cAMD"
682 if (EBX == 0x68747541 && EDX == 0x69746e65 && ECX == 0x444d4163)
683 return VendorSignatures::AUTHENTIC_AMD;
684
685 return VendorSignatures::UNKNOWN;
686}
687
688} // namespace x86
689} // namespace detail
690} // namespace sys
691} // namespace llvm
692
693using namespace llvm::sys::detail::x86;
694
695/// getX86CpuIDAndInfoEx - Execute the specified cpuid with subleaf and return
696/// the 4 values in the specified arguments. If we can't run cpuid on the host,
697/// return true.
698static bool getX86CpuIDAndInfoEx(unsigned value, unsigned subleaf,
699 unsigned *rEAX, unsigned *rEBX, unsigned *rECX,
700 unsigned *rEDX) {
701 // TODO(boomanaiden154): When the minimum toolchain versions for gcc and clang
702 // are such that __cpuidex is defined within cpuid.h for both, we can remove
703 // the __get_cpuid_count function and share the MSVC implementation between
704 // all three.
705#if (defined(__i386__) || defined(__x86_64__)) && !defined(_MSC_VER)
706 return !__get_cpuid_count(value, subleaf, rEAX, rEBX, rECX, rEDX);
707#elif defined(_MSC_VER)
708 int registers[4];
709 __cpuidex(registers, value, subleaf);
710 *rEAX = registers[0];
711 *rEBX = registers[1];
712 *rECX = registers[2];
713 *rEDX = registers[3];
714 return false;
715#else
716 return true;
717#endif
718}
719
720// Read control register 0 (XCR0). Used to detect features such as AVX.
721static bool getX86XCR0(unsigned *rEAX, unsigned *rEDX) {
722 // TODO(boomanaiden154): When the minimum toolchain versions for gcc and clang
723 // are such that _xgetbv is supported by both, we can unify the implementation
724 // with MSVC and remove all inline assembly.
725#if defined(__GNUC__) || defined(__clang__)
726 // Check xgetbv; this uses a .byte sequence instead of the instruction
727 // directly because older assemblers do not include support for xgetbv and
728 // there is no easy way to conditionally compile based on the assembler used.
729 __asm__(".byte 0x0f, 0x01, 0xd0" : "=a"(*rEAX), "=d"(*rEDX) : "c"(0));
730 return false;
731#elif defined(_MSC_FULL_VER) && defined(_XCR_XFEATURE_ENABLED_MASK)
732 unsigned long long Result = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
733 *rEAX = Result;
734 *rEDX = Result >> 32;
735 return false;
736#else
737 return true;
738#endif
739}
740
741static void detectX86FamilyModel(unsigned EAX, unsigned *Family,
742 unsigned *Model) {
743 *Family = (EAX >> 8) & 0xf; // Bits 8 - 11
744 *Model = (EAX >> 4) & 0xf; // Bits 4 - 7
745 if (*Family == 6 || *Family == 0xf) {
746 if (*Family == 0xf)
747 // Examine extended family ID if family ID is F.
748 *Family += (EAX >> 20) & 0xff; // Bits 20 - 27
749 // Examine extended model ID if family ID is 6 or F.
750 *Model += ((EAX >> 16) & 0xf) << 4; // Bits 16 - 19
751 }
752}
753
754#define testFeature(F) (Features[F / 32] & (1 << (F % 32))) != 0
755
756static StringRef getIntelProcessorTypeAndSubtype(unsigned Family,
757 unsigned Model,
758 const unsigned *Features,
759 unsigned *Type,
760 unsigned *Subtype) {
761 StringRef CPU;
762
763 switch (Family) {
764 case 0x3:
765 CPU = "i386";
766 break;
767 case 0x4:
768 CPU = "i486";
769 break;
770 case 0x5:
771 if (testFeature(X86::FEATURE_MMX)) {
772 CPU = "pentium-mmx";
773 break;
774 }
775 CPU = "pentium";
776 break;
777 case 0x6:
778 switch (Model) {
779 case 0x0f: // Intel Core 2 Duo processor, Intel Core 2 Duo mobile
780 // processor, Intel Core 2 Quad processor, Intel Core 2 Quad
781 // mobile processor, Intel Core 2 Extreme processor, Intel
782 // Pentium Dual-Core processor, Intel Xeon processor, model
783 // 0Fh. All processors are manufactured using the 65 nm process.
784 case 0x16: // Intel Celeron processor model 16h. All processors are
785 // manufactured using the 65 nm process
786 CPU = "core2";
787 *Type = X86::INTEL_CORE2;
788 break;
789 case 0x17: // Intel Core 2 Extreme processor, Intel Xeon processor, model
790 // 17h. All processors are manufactured using the 45 nm process.
791 //
792 // 45nm: Penryn , Wolfdale, Yorkfield (XE)
793 case 0x1d: // Intel Xeon processor MP. All processors are manufactured using
794 // the 45 nm process.
795 CPU = "penryn";
796 *Type = X86::INTEL_CORE2;
797 break;
798 case 0x1a: // Intel Core i7 processor and Intel Xeon processor. All
799 // processors are manufactured using the 45 nm process.
800 case 0x1e: // Intel(R) Core(TM) i7 CPU 870 @ 2.93GHz.
801 // As found in a Summer 2010 model iMac.
802 case 0x1f:
803 case 0x2e: // Nehalem EX
804 CPU = "nehalem";
805 *Type = X86::INTEL_COREI7;
806 *Subtype = X86::INTEL_COREI7_NEHALEM;
807 break;
808 case 0x25: // Intel Core i7, laptop version.
809 case 0x2c: // Intel Core i7 processor and Intel Xeon processor. All
810 // processors are manufactured using the 32 nm process.
811 case 0x2f: // Westmere EX
812 CPU = "westmere";
813 *Type = X86::INTEL_COREI7;
814 *Subtype = X86::INTEL_COREI7_WESTMERE;
815 break;
816 case 0x2a: // Intel Core i7 processor. All processors are manufactured
817 // using the 32 nm process.
818 case 0x2d:
819 CPU = "sandybridge";
820 *Type = X86::INTEL_COREI7;
821 *Subtype = X86::INTEL_COREI7_SANDYBRIDGE;
822 break;
823 case 0x3a:
824 case 0x3e: // Ivy Bridge EP
825 CPU = "ivybridge";
826 *Type = X86::INTEL_COREI7;
827 *Subtype = X86::INTEL_COREI7_IVYBRIDGE;
828 break;
829
830 // Haswell:
831 case 0x3c:
832 case 0x3f:
833 case 0x45:
834 case 0x46:
835 CPU = "haswell";
836 *Type = X86::INTEL_COREI7;
837 *Subtype = X86::INTEL_COREI7_HASWELL;
838 break;
839
840 // Broadwell:
841 case 0x3d:
842 case 0x47:
843 case 0x4f:
844 case 0x56:
845 CPU = "broadwell";
846 *Type = X86::INTEL_COREI7;
847 *Subtype = X86::INTEL_COREI7_BROADWELL;
848 break;
849
850 // Skylake:
851 case 0x4e: // Skylake mobile
852 case 0x5e: // Skylake desktop
853 case 0x8e: // Kaby Lake mobile
854 case 0x9e: // Kaby Lake desktop
855 case 0xa5: // Comet Lake-H/S
856 case 0xa6: // Comet Lake-U
857 CPU = "skylake";
858 *Type = X86::INTEL_COREI7;
859 *Subtype = X86::INTEL_COREI7_SKYLAKE;
860 break;
861
862 // Rocketlake:
863 case 0xa7:
864 CPU = "rocketlake";
865 *Type = X86::INTEL_COREI7;
866 *Subtype = X86::INTEL_COREI7_ROCKETLAKE;
867 break;
868
869 // Skylake Xeon:
870 case 0x55:
871 *Type = X86::INTEL_COREI7;
872 if (testFeature(X86::FEATURE_AVX512BF16)) {
873 CPU = "cooperlake";
874 *Subtype = X86::INTEL_COREI7_COOPERLAKE;
875 } else if (testFeature(X86::FEATURE_AVX512VNNI)) {
876 CPU = "cascadelake";
877 *Subtype = X86::INTEL_COREI7_CASCADELAKE;
878 } else {
879 CPU = "skylake-avx512";
880 *Subtype = X86::INTEL_COREI7_SKYLAKE_AVX512;
881 }
882 break;
883
884 // Cannonlake:
885 case 0x66:
886 CPU = "cannonlake";
887 *Type = X86::INTEL_COREI7;
888 *Subtype = X86::INTEL_COREI7_CANNONLAKE;
889 break;
890
891 // Icelake:
892 case 0x7d:
893 case 0x7e:
894 CPU = "icelake-client";
895 *Type = X86::INTEL_COREI7;
896 *Subtype = X86::INTEL_COREI7_ICELAKE_CLIENT;
897 break;
898
899 // Tigerlake:
900 case 0x8c:
901 case 0x8d:
902 CPU = "tigerlake";
903 *Type = X86::INTEL_COREI7;
904 *Subtype = X86::INTEL_COREI7_TIGERLAKE;
905 break;
906
907 // Alderlake:
908 case 0x97:
909 case 0x9a:
910 CPU = "alderlake";
911 *Type = X86::INTEL_COREI7;
912 *Subtype = X86::INTEL_COREI7_ALDERLAKE;
913 break;
914
915 // Gracemont
916 case 0xbe:
917 CPU = "gracemont";
918 *Type = X86::INTEL_COREI7;
919 *Subtype = X86::INTEL_COREI7_ALDERLAKE;
920 break;
921
922 // Raptorlake:
923 case 0xb7:
924 case 0xba:
925 case 0xbf:
926 CPU = "raptorlake";
927 *Type = X86::INTEL_COREI7;
928 *Subtype = X86::INTEL_COREI7_ALDERLAKE;
929 break;
930
931 // Meteorlake:
932 case 0xaa:
933 case 0xac:
934 CPU = "meteorlake";
935 *Type = X86::INTEL_COREI7;
936 *Subtype = X86::INTEL_COREI7_ALDERLAKE;
937 break;
938
939 // Arrowlake:
940 case 0xc5:
941 // Arrowlake U:
942 case 0xb5:
943 CPU = "arrowlake";
944 *Type = X86::INTEL_COREI7;
945 *Subtype = X86::INTEL_COREI7_ARROWLAKE;
946 break;
947
948 // Arrowlake S:
949 case 0xc6:
950 CPU = "arrowlake-s";
951 *Type = X86::INTEL_COREI7;
952 *Subtype = X86::INTEL_COREI7_ARROWLAKE_S;
953 break;
954
955 // Lunarlake:
956 case 0xbd:
957 CPU = "lunarlake";
958 *Type = X86::INTEL_COREI7;
959 *Subtype = X86::INTEL_COREI7_ARROWLAKE_S;
960 break;
961
962 // Pantherlake:
963 case 0xcc:
964 CPU = "pantherlake";
965 *Type = X86::INTEL_COREI7;
966 *Subtype = X86::INTEL_COREI7_PANTHERLAKE;
967 break;
968
969 // Wildcatlake:
970 case 0xd5:
971 CPU = "wildcatlake";
972 *Type = X86::INTEL_COREI7;
973 *Subtype = X86::INTEL_COREI7_PANTHERLAKE;
974 break;
975
976 // Graniterapids:
977 case 0xad:
978 CPU = "graniterapids";
979 *Type = X86::INTEL_COREI7;
980 *Subtype = X86::INTEL_COREI7_GRANITERAPIDS;
981 break;
982
983 // Granite Rapids D:
984 case 0xae:
985 CPU = "graniterapids-d";
986 *Type = X86::INTEL_COREI7;
987 *Subtype = X86::INTEL_COREI7_GRANITERAPIDS_D;
988 break;
989
990 // Icelake Xeon:
991 case 0x6a:
992 case 0x6c:
993 CPU = "icelake-server";
994 *Type = X86::INTEL_COREI7;
995 *Subtype = X86::INTEL_COREI7_ICELAKE_SERVER;
996 break;
997
998 // Emerald Rapids:
999 case 0xcf:
1000 CPU = "emeraldrapids";
1001 *Type = X86::INTEL_COREI7;
1002 *Subtype = X86::INTEL_COREI7_SAPPHIRERAPIDS;
1003 break;
1004
1005 // Sapphire Rapids:
1006 case 0x8f:
1007 CPU = "sapphirerapids";
1008 *Type = X86::INTEL_COREI7;
1009 *Subtype = X86::INTEL_COREI7_SAPPHIRERAPIDS;
1010 break;
1011
1012 case 0x1c: // Most 45 nm Intel Atom processors
1013 case 0x26: // 45 nm Atom Lincroft
1014 case 0x27: // 32 nm Atom Medfield
1015 case 0x35: // 32 nm Atom Midview
1016 case 0x36: // 32 nm Atom Midview
1017 CPU = "bonnell";
1018 *Type = X86::INTEL_BONNELL;
1019 break;
1020
1021 // Atom Silvermont codes from the Intel software optimization guide.
1022 case 0x37:
1023 case 0x4a:
1024 case 0x4d:
1025 case 0x5a:
1026 case 0x5d:
1027 case 0x4c: // really airmont
1028 CPU = "silvermont";
1029 *Type = X86::INTEL_SILVERMONT;
1030 break;
1031 // Goldmont:
1032 case 0x5c: // Apollo Lake
1033 case 0x5f: // Denverton
1034 CPU = "goldmont";
1035 *Type = X86::INTEL_GOLDMONT;
1036 break;
1037 case 0x7a:
1038 CPU = "goldmont-plus";
1039 *Type = X86::INTEL_GOLDMONT_PLUS;
1040 break;
1041 case 0x86:
1042 case 0x8a: // Lakefield
1043 case 0x96: // Elkhart Lake
1044 case 0x9c: // Jasper Lake
1045 CPU = "tremont";
1046 *Type = X86::INTEL_TREMONT;
1047 break;
1048
1049 // Sierraforest:
1050 case 0xaf:
1051 CPU = "sierraforest";
1052 *Type = X86::INTEL_SIERRAFOREST;
1053 break;
1054
1055 // Grandridge:
1056 case 0xb6:
1057 CPU = "grandridge";
1058 *Type = X86::INTEL_GRANDRIDGE;
1059 break;
1060
1061 // Clearwaterforest:
1062 case 0xdd:
1063 CPU = "clearwaterforest";
1064 *Type = X86::INTEL_CLEARWATERFOREST;
1065 break;
1066
1067 // Xeon Phi (Knights Landing + Knights Mill):
1068 case 0x57:
1069 CPU = "knl";
1070 *Type = X86::INTEL_KNL;
1071 break;
1072 case 0x85:
1073 CPU = "knm";
1074 *Type = X86::INTEL_KNM;
1075 break;
1076
1077 default: // Unknown family 6 CPU, try to guess.
1078 // Don't both with Type/Subtype here, they aren't used by the caller.
1079 // They're used above to keep the code in sync with compiler-rt.
1080 // TODO detect tigerlake host from model
1081 if (testFeature(X86::FEATURE_AVX512VP2INTERSECT)) {
1082 CPU = "tigerlake";
1083 } else if (testFeature(X86::FEATURE_AVX512VBMI2)) {
1084 CPU = "icelake-client";
1085 } else if (testFeature(X86::FEATURE_AVX512VBMI)) {
1086 CPU = "cannonlake";
1087 } else if (testFeature(X86::FEATURE_AVX512BF16)) {
1088 CPU = "cooperlake";
1089 } else if (testFeature(X86::FEATURE_AVX512VNNI)) {
1090 CPU = "cascadelake";
1091 } else if (testFeature(X86::FEATURE_AVX512VL)) {
1092 CPU = "skylake-avx512";
1093 } else if (testFeature(X86::FEATURE_CLFLUSHOPT)) {
1094 if (testFeature(X86::FEATURE_SHA))
1095 CPU = "goldmont";
1096 else
1097 CPU = "skylake";
1098 } else if (testFeature(X86::FEATURE_ADX)) {
1099 CPU = "broadwell";
1100 } else if (testFeature(X86::FEATURE_AVX2)) {
1101 CPU = "haswell";
1102 } else if (testFeature(X86::FEATURE_AVX)) {
1103 CPU = "sandybridge";
1104 } else if (testFeature(X86::FEATURE_SSE4_2)) {
1105 if (testFeature(X86::FEATURE_MOVBE))
1106 CPU = "silvermont";
1107 else
1108 CPU = "nehalem";
1109 } else if (testFeature(X86::FEATURE_SSE4_1)) {
1110 CPU = "penryn";
1111 } else if (testFeature(X86::FEATURE_SSSE3)) {
1112 if (testFeature(X86::FEATURE_MOVBE))
1113 CPU = "bonnell";
1114 else
1115 CPU = "core2";
1116 } else if (testFeature(X86::FEATURE_64BIT)) {
1117 CPU = "core2";
1118 } else if (testFeature(X86::FEATURE_SSE3)) {
1119 CPU = "yonah";
1120 } else if (testFeature(X86::FEATURE_SSE2)) {
1121 CPU = "pentium-m";
1122 } else if (testFeature(X86::FEATURE_SSE)) {
1123 CPU = "pentium3";
1124 } else if (testFeature(X86::FEATURE_MMX)) {
1125 CPU = "pentium2";
1126 } else {
1127 CPU = "pentiumpro";
1128 }
1129 break;
1130 }
1131 break;
1132 case 0xf: {
1133 if (testFeature(X86::FEATURE_64BIT)) {
1134 CPU = "nocona";
1135 break;
1136 }
1137 if (testFeature(X86::FEATURE_SSE3)) {
1138 CPU = "prescott";
1139 break;
1140 }
1141 CPU = "pentium4";
1142 break;
1143 }
1144 case 0x13:
1145 switch (Model) {
1146 // Diamond Rapids:
1147 case 0x01:
1148 CPU = "diamondrapids";
1149 *Type = X86::INTEL_COREI7;
1150 *Subtype = X86::INTEL_COREI7_DIAMONDRAPIDS;
1151 break;
1152
1153 default: // Unknown family 19 CPU.
1154 break;
1155 }
1156 break;
1157 case 0x12:
1158 switch (Model) {
1159 // Novalake:
1160 case 0x1:
1161 case 0x3:
1162 CPU = "novalake";
1163 *Type = X86::INTEL_COREI7;
1164 *Subtype = X86::INTEL_COREI7_NOVALAKE;
1165 break;
1166 default: // Unknown family 0x12 CPU.
1167 break;
1168 }
1169 break;
1170
1171 default:
1172 break; // Unknown.
1173 }
1174
1175 return CPU;
1176}
1177
1178static const char *getAMDProcessorTypeAndSubtype(unsigned Family,
1179 unsigned Model,
1180 const unsigned *Features,
1181 unsigned *Type,
1182 unsigned *Subtype) {
1183 const char *CPU = nullptr;
1184
1185 switch (Family) {
1186 case 4:
1187 CPU = "i486";
1188 break;
1189 case 5:
1190 CPU = "pentium";
1191 switch (Model) {
1192 case 6:
1193 case 7:
1194 CPU = "k6";
1195 break;
1196 case 8:
1197 CPU = "k6-2";
1198 break;
1199 case 9:
1200 case 13:
1201 CPU = "k6-3";
1202 break;
1203 case 10:
1204 CPU = "geode";
1205 break;
1206 }
1207 break;
1208 case 6:
1209 if (testFeature(X86::FEATURE_SSE)) {
1210 CPU = "athlon-xp";
1211 break;
1212 }
1213 CPU = "athlon";
1214 break;
1215 case 15:
1216 if (testFeature(X86::FEATURE_SSE3)) {
1217 CPU = "k8-sse3";
1218 break;
1219 }
1220 CPU = "k8";
1221 break;
1222 case 16:
1223 case 18:
1224 CPU = "amdfam10";
1225 *Type = X86::AMDFAM10H; // "amdfam10"
1226 switch (Model) {
1227 case 2:
1228 *Subtype = X86::AMDFAM10H_BARCELONA;
1229 break;
1230 case 4:
1231 *Subtype = X86::AMDFAM10H_SHANGHAI;
1232 break;
1233 case 8:
1234 *Subtype = X86::AMDFAM10H_ISTANBUL;
1235 break;
1236 }
1237 break;
1238 case 20:
1239 CPU = "btver1";
1240 *Type = X86::AMD_BTVER1;
1241 break;
1242 case 21:
1243 CPU = "bdver1";
1244 *Type = X86::AMDFAM15H;
1245 if (Model >= 0x60 && Model <= 0x7f) {
1246 CPU = "bdver4";
1247 *Subtype = X86::AMDFAM15H_BDVER4;
1248 break; // 60h-7Fh: Excavator
1249 }
1250 if (Model >= 0x30 && Model <= 0x3f) {
1251 CPU = "bdver3";
1252 *Subtype = X86::AMDFAM15H_BDVER3;
1253 break; // 30h-3Fh: Steamroller
1254 }
1255 if ((Model >= 0x10 && Model <= 0x1f) || Model == 0x02) {
1256 CPU = "bdver2";
1257 *Subtype = X86::AMDFAM15H_BDVER2;
1258 break; // 02h, 10h-1Fh: Piledriver
1259 }
1260 if (Model <= 0x0f) {
1261 *Subtype = X86::AMDFAM15H_BDVER1;
1262 break; // 00h-0Fh: Bulldozer
1263 }
1264 break;
1265 case 22:
1266 CPU = "btver2";
1267 *Type = X86::AMD_BTVER2;
1268 break;
1269 case 23:
1270 CPU = "znver1";
1271 *Type = X86::AMDFAM17H;
1272 if ((Model >= 0x30 && Model <= 0x3f) || (Model == 0x47) ||
1273 (Model >= 0x60 && Model <= 0x67) || (Model >= 0x68 && Model <= 0x6f) ||
1274 (Model >= 0x70 && Model <= 0x7f) || (Model >= 0x84 && Model <= 0x87) ||
1275 (Model >= 0x90 && Model <= 0x97) || (Model >= 0x98 && Model <= 0x9f) ||
1276 (Model >= 0xa0 && Model <= 0xaf)) {
1277 // Family 17h Models 30h-3Fh (Starship) Zen 2
1278 // Family 17h Models 47h (Cardinal) Zen 2
1279 // Family 17h Models 60h-67h (Renoir) Zen 2
1280 // Family 17h Models 68h-6Fh (Lucienne) Zen 2
1281 // Family 17h Models 70h-7Fh (Matisse) Zen 2
1282 // Family 17h Models 84h-87h (ProjectX) Zen 2
1283 // Family 17h Models 90h-97h (VanGogh) Zen 2
1284 // Family 17h Models 98h-9Fh (Mero) Zen 2
1285 // Family 17h Models A0h-AFh (Mendocino) Zen 2
1286 CPU = "znver2";
1287 *Subtype = X86::AMDFAM17H_ZNVER2;
1288 break;
1289 }
1290 if ((Model >= 0x10 && Model <= 0x1f) || (Model >= 0x20 && Model <= 0x2f)) {
1291 // Family 17h Models 10h-1Fh (Raven1) Zen
1292 // Family 17h Models 10h-1Fh (Picasso) Zen+
1293 // Family 17h Models 20h-2Fh (Raven2 x86) Zen
1294 *Subtype = X86::AMDFAM17H_ZNVER1;
1295 break;
1296 }
1297 break;
1298 case 25:
1299 CPU = "znver3";
1300 *Type = X86::AMDFAM19H;
1301 if (Model <= 0x0f || (Model >= 0x20 && Model <= 0x2f) ||
1302 (Model >= 0x30 && Model <= 0x3f) || (Model >= 0x40 && Model <= 0x4f) ||
1303 (Model >= 0x50 && Model <= 0x5f)) {
1304 // Family 19h Models 00h-0Fh (Genesis, Chagall) Zen 3
1305 // Family 19h Models 20h-2Fh (Vermeer) Zen 3
1306 // Family 19h Models 30h-3Fh (Badami) Zen 3
1307 // Family 19h Models 40h-4Fh (Rembrandt) Zen 3+
1308 // Family 19h Models 50h-5Fh (Cezanne) Zen 3
1309 *Subtype = X86::AMDFAM19H_ZNVER3;
1310 break;
1311 }
1312 if ((Model >= 0x10 && Model <= 0x1f) || (Model >= 0x60 && Model <= 0x6f) ||
1313 (Model >= 0x70 && Model <= 0x77) || (Model >= 0x78 && Model <= 0x7f) ||
1314 (Model >= 0xa0 && Model <= 0xaf)) {
1315 // Family 19h Models 10h-1Fh (Stones; Storm Peak) Zen 4
1316 // Family 19h Models 60h-6Fh (Raphael) Zen 4
1317 // Family 19h Models 70h-77h (Phoenix, Hawkpoint1) Zen 4
1318 // Family 19h Models 78h-7Fh (Phoenix 2, Hawkpoint2) Zen 4
1319 // Family 19h Models A0h-AFh (Stones-Dense) Zen 4
1320 CPU = "znver4";
1321 *Subtype = X86::AMDFAM19H_ZNVER4;
1322 break; // "znver4"
1323 }
1324 break; // family 19h
1325 case 26:
1326 CPU = "znver5";
1327 *Type = X86::AMDFAM1AH;
1328 if (Model <= 0x4f || (Model >= 0x60 && Model <= 0x77) ||
1329 (Model >= 0xd0 && Model <= 0xd7)) {
1330 // Models 00h-0Fh (Breithorn).
1331 // Models 10h-1Fh (Breithorn-Dense).
1332 // Models 20h-2Fh (Strix 1).
1333 // Models 30h-37h (Strix 2).
1334 // Models 38h-3Fh (Strix 3).
1335 // Models 40h-4Fh (Granite Ridge).
1336 // Models 60h-6Fh (Krackan1).
1337 // Models 70h-77h (Sarlak).
1338 // Models D0h-D7h (Annapurna).
1339 CPU = "znver5";
1340 *Subtype = X86::AMDFAM1AH_ZNVER5;
1341 break; // "znver5"
1342 }
1343 break;
1344
1345 default:
1346 break; // Unknown AMD CPU.
1347 }
1348
1349 return CPU;
1350}
1351
1352#undef testFeature
1353
1354static void getAvailableFeatures(unsigned ECX, unsigned EDX, unsigned MaxLeaf,
1355 unsigned *Features) {
1356 unsigned EAX, EBX;
1357
1358 auto setFeature = [&](unsigned F) {
1359 Features[F / 32] |= 1U << (F % 32);
1360 };
1361
1362 if ((EDX >> 15) & 1)
1363 setFeature(X86::FEATURE_CMOV);
1364 if ((EDX >> 23) & 1)
1365 setFeature(X86::FEATURE_MMX);
1366 if ((EDX >> 25) & 1)
1367 setFeature(X86::FEATURE_SSE);
1368 if ((EDX >> 26) & 1)
1369 setFeature(X86::FEATURE_SSE2);
1370
1371 if ((ECX >> 0) & 1)
1372 setFeature(X86::FEATURE_SSE3);
1373 if ((ECX >> 1) & 1)
1374 setFeature(X86::FEATURE_PCLMUL);
1375 if ((ECX >> 9) & 1)
1376 setFeature(X86::FEATURE_SSSE3);
1377 if ((ECX >> 12) & 1)
1378 setFeature(X86::FEATURE_FMA);
1379 if ((ECX >> 19) & 1)
1380 setFeature(X86::FEATURE_SSE4_1);
1381 if ((ECX >> 20) & 1) {
1382 setFeature(X86::FEATURE_SSE4_2);
1383 setFeature(X86::FEATURE_CRC32);
1384 }
1385 if ((ECX >> 23) & 1)
1386 setFeature(X86::FEATURE_POPCNT);
1387 if ((ECX >> 25) & 1)
1388 setFeature(X86::FEATURE_AES);
1389
1390 if ((ECX >> 22) & 1)
1391 setFeature(X86::FEATURE_MOVBE);
1392
1393 // If CPUID indicates support for XSAVE, XRESTORE and AVX, and XGETBV
1394 // indicates that the AVX registers will be saved and restored on context
1395 // switch, then we have full AVX support.
1396 const unsigned AVXBits = (1 << 27) | (1 << 28);
1397 bool HasAVX = ((ECX & AVXBits) == AVXBits) && !getX86XCR0(&EAX, &EDX) &&
1398 ((EAX & 0x6) == 0x6);
1399#if defined(__APPLE__)
1400 // Darwin lazily saves the AVX512 context on first use: trust that the OS will
1401 // save the AVX512 context if we use AVX512 instructions, even the bit is not
1402 // set right now.
1403 bool HasAVX512Save = true;
1404#else
1405 // AVX512 requires additional context to be saved by the OS.
1406 bool HasAVX512Save = HasAVX && ((EAX & 0xe0) == 0xe0);
1407#endif
1408
1409 if (HasAVX)
1410 setFeature(X86::FEATURE_AVX);
1411
1412 bool HasLeaf7 =
1413 MaxLeaf >= 0x7 && !getX86CpuIDAndInfoEx(0x7, 0x0, &EAX, &EBX, &ECX, &EDX);
1414
1415 if (HasLeaf7 && ((EBX >> 3) & 1))
1416 setFeature(X86::FEATURE_BMI);
1417 if (HasLeaf7 && ((EBX >> 5) & 1) && HasAVX)
1418 setFeature(X86::FEATURE_AVX2);
1419 if (HasLeaf7 && ((EBX >> 8) & 1))
1420 setFeature(X86::FEATURE_BMI2);
1421 if (HasLeaf7 && ((EBX >> 16) & 1) && HasAVX512Save) {
1422 setFeature(X86::FEATURE_AVX512F);
1423 }
1424 if (HasLeaf7 && ((EBX >> 17) & 1) && HasAVX512Save)
1425 setFeature(X86::FEATURE_AVX512DQ);
1426 if (HasLeaf7 && ((EBX >> 19) & 1))
1427 setFeature(X86::FEATURE_ADX);
1428 if (HasLeaf7 && ((EBX >> 21) & 1) && HasAVX512Save)
1429 setFeature(X86::FEATURE_AVX512IFMA);
1430 if (HasLeaf7 && ((EBX >> 23) & 1))
1431 setFeature(X86::FEATURE_CLFLUSHOPT);
1432 if (HasLeaf7 && ((EBX >> 28) & 1) && HasAVX512Save)
1433 setFeature(X86::FEATURE_AVX512CD);
1434 if (HasLeaf7 && ((EBX >> 29) & 1))
1435 setFeature(X86::FEATURE_SHA);
1436 if (HasLeaf7 && ((EBX >> 30) & 1) && HasAVX512Save)
1437 setFeature(X86::FEATURE_AVX512BW);
1438 if (HasLeaf7 && ((EBX >> 31) & 1) && HasAVX512Save)
1439 setFeature(X86::FEATURE_AVX512VL);
1440
1441 if (HasLeaf7 && ((ECX >> 1) & 1) && HasAVX512Save)
1442 setFeature(X86::FEATURE_AVX512VBMI);
1443 if (HasLeaf7 && ((ECX >> 6) & 1) && HasAVX512Save)
1444 setFeature(X86::FEATURE_AVX512VBMI2);
1445 if (HasLeaf7 && ((ECX >> 8) & 1))
1446 setFeature(X86::FEATURE_GFNI);
1447 if (HasLeaf7 && ((ECX >> 10) & 1) && HasAVX)
1448 setFeature(X86::FEATURE_VPCLMULQDQ);
1449 if (HasLeaf7 && ((ECX >> 11) & 1) && HasAVX512Save)
1450 setFeature(X86::FEATURE_AVX512VNNI);
1451 if (HasLeaf7 && ((ECX >> 12) & 1) && HasAVX512Save)
1452 setFeature(X86::FEATURE_AVX512BITALG);
1453 if (HasLeaf7 && ((ECX >> 14) & 1) && HasAVX512Save)
1454 setFeature(X86::FEATURE_AVX512VPOPCNTDQ);
1455
1456 if (HasLeaf7 && ((EDX >> 2) & 1) && HasAVX512Save)
1457 setFeature(X86::FEATURE_AVX5124VNNIW);
1458 if (HasLeaf7 && ((EDX >> 3) & 1) && HasAVX512Save)
1459 setFeature(X86::FEATURE_AVX5124FMAPS);
1460 if (HasLeaf7 && ((EDX >> 8) & 1) && HasAVX512Save)
1461 setFeature(X86::FEATURE_AVX512VP2INTERSECT);
1462
1463 // EAX from subleaf 0 is the maximum subleaf supported. Some CPUs don't
1464 // return all 0s for invalid subleaves so check the limit.
1465 bool HasLeaf7Subleaf1 =
1466 HasLeaf7 && EAX >= 1 &&
1467 !getX86CpuIDAndInfoEx(0x7, 0x1, &EAX, &EBX, &ECX, &EDX);
1468 if (HasLeaf7Subleaf1 && ((EAX >> 5) & 1) && HasAVX512Save)
1469 setFeature(X86::FEATURE_AVX512BF16);
1470
1471 unsigned MaxExtLevel;
1472 getX86CpuIDAndInfo(0x80000000, &MaxExtLevel, &EBX, &ECX, &EDX);
1473
1474 bool HasExtLeaf1 = MaxExtLevel >= 0x80000001 &&
1475 !getX86CpuIDAndInfo(0x80000001, &EAX, &EBX, &ECX, &EDX);
1476 if (HasExtLeaf1 && ((ECX >> 6) & 1))
1477 setFeature(X86::FEATURE_SSE4_A);
1478 if (HasExtLeaf1 && ((ECX >> 11) & 1))
1479 setFeature(X86::FEATURE_XOP);
1480 if (HasExtLeaf1 && ((ECX >> 16) & 1))
1481 setFeature(X86::FEATURE_FMA4);
1482
1483 if (HasExtLeaf1 && ((EDX >> 29) & 1))
1484 setFeature(X86::FEATURE_64BIT);
1485}
1486
1487StringRef sys::getHostCPUName() {
1488 unsigned MaxLeaf = 0;
1489 const VendorSignatures Vendor = getVendorSignature(&MaxLeaf);
1490 if (Vendor == VendorSignatures::UNKNOWN)
1491 return "generic";
1492
1493 unsigned EAX = 0, EBX = 0, ECX = 0, EDX = 0;
1494 getX86CpuIDAndInfo(0x1, &EAX, &EBX, &ECX, &EDX);
1495
1496 unsigned Family = 0, Model = 0;
1497 unsigned Features[(X86::CPU_FEATURE_MAX + 31) / 32] = {0};
1498 detectX86FamilyModel(EAX, &Family, &Model);
1499 getAvailableFeatures(ECX, EDX, MaxLeaf, Features);
1500
1501 // These aren't consumed in this file, but we try to keep some source code the
1502 // same or similar to compiler-rt.
1503 unsigned Type = 0;
1504 unsigned Subtype = 0;
1505
1506 StringRef CPU;
1507
1508 if (Vendor == VendorSignatures::GENUINE_INTEL) {
1509 CPU = getIntelProcessorTypeAndSubtype(Family, Model, Features, &Type,
1510 &Subtype);
1511 } else if (Vendor == VendorSignatures::AUTHENTIC_AMD) {
1512 CPU = getAMDProcessorTypeAndSubtype(Family, Model, Features, &Type,
1513 &Subtype);
1514 }
1515
1516 if (!CPU.empty())
1517 return CPU;
1518
1519 return "generic";
1520}
1521
1522#elif defined(_M_ARM64) || defined(_M_ARM64EC)
1523
1524StringRef sys::getHostCPUName() {
1525 constexpr char CentralProcessorKeyName[] =
1526 "HARDWARE\\DESCRIPTION\\System\\CentralProcessor";
1527 // Sub keys names are simple numbers ("0", "1", etc.) so 10 chars should be
1528 // enough for the slash and name.
1529 constexpr size_t SubKeyNameMaxSize = ARRAYSIZE(CentralProcessorKeyName) + 10;
1530
1531 SmallVector<uint64_t> Values;
1532 uint64_t PrimaryCpuInfo;
1533 char PrimaryPartKeyName[SubKeyNameMaxSize];
1534 DWORD PrimaryPartKeyNameSize = 0;
1535 HKEY CentralProcessorKey;
1536 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, CentralProcessorKeyName, 0, KEY_READ,
1537 &CentralProcessorKey) == ERROR_SUCCESS) {
1538 for (unsigned Index = 0; Index < UINT32_MAX; ++Index) {
1539 char SubKeyName[SubKeyNameMaxSize];
1540 DWORD SubKeySize = SubKeyNameMaxSize;
1541 HKEY SubKey;
1542 if ((RegEnumKeyExA(CentralProcessorKey, Index, SubKeyName, &SubKeySize,
1543 nullptr, nullptr, nullptr,
1544 nullptr) == ERROR_SUCCESS) &&
1545 (RegOpenKeyExA(CentralProcessorKey, SubKeyName, 0, KEY_READ,
1546 &SubKey) == ERROR_SUCCESS)) {
1547 // The "CP 4000" registry key contains a cached copy of the MIDR_EL1
1548 // register.
1549 uint64_t RegValue;
1550 DWORD ActualType;
1551 DWORD RegValueSize = sizeof(RegValue);
1552 if ((RegQueryValueExA(SubKey, "CP 4000", nullptr, &ActualType,
1553 (PBYTE)&RegValue,
1554 &RegValueSize) == ERROR_SUCCESS) &&
1555 (ActualType == REG_QWORD) && RegValueSize == sizeof(RegValue)) {
1556 // Assume that the part with the "highest" reg key name is the primary
1557 // part (to match the way that Linux's cpuinfo is written). Win32
1558 // makes no guarantees about the order of sub keys, so we have to
1559 // compare the names.
1560 if (PrimaryPartKeyNameSize < SubKeySize ||
1561 (PrimaryPartKeyNameSize == SubKeySize &&
1562 ::memcmp(SubKeyName, PrimaryPartKeyName, SubKeySize) > 0)) {
1563 PrimaryCpuInfo = RegValue;
1564 ::memcpy(PrimaryPartKeyName, SubKeyName, SubKeySize + 1);
1565 PrimaryPartKeyNameSize = SubKeySize;
1566 }
1567 if (!llvm::is_contained(Values, RegValue)) {
1568 Values.push_back(RegValue);
1569 }
1570 }
1571 RegCloseKey(SubKey);
1572 } else {
1573 // No more sub keys.
1574 break;
1575 }
1576 }
1577 RegCloseKey(CentralProcessorKey);
1578 }
1579
1580 if (Values.empty()) {
1581 return "generic";
1582 }
1583
1584 // Win32 makes no guarantees about the order of sub keys, so sort to ensure
1585 // reproducibility.
1586 llvm::sort(Values);
1587
1588 return detail::getHostCPUNameForARM(PrimaryCpuInfo, Values);
1589}
1590
1591#elif defined(__APPLE__) && defined(__powerpc__)
1592StringRef sys::getHostCPUName() {
1593 host_basic_info_data_t hostInfo;
1594 mach_msg_type_number_t infoCount;
1595
1596 infoCount = HOST_BASIC_INFO_COUNT;
1597 mach_port_t hostPort = mach_host_self();
1598 host_info(hostPort, HOST_BASIC_INFO, (host_info_t)&hostInfo,
1599 &infoCount);
1600 mach_port_deallocate(mach_task_self(), hostPort);
1601
1602 if (hostInfo.cpu_type != CPU_TYPE_POWERPC)
1603 return "generic";
1604
1605 switch (hostInfo.cpu_subtype) {
1606 case CPU_SUBTYPE_POWERPC_601:
1607 return "601";
1608 case CPU_SUBTYPE_POWERPC_602:
1609 return "602";
1610 case CPU_SUBTYPE_POWERPC_603:
1611 return "603";
1612 case CPU_SUBTYPE_POWERPC_603e:
1613 return "603e";
1614 case CPU_SUBTYPE_POWERPC_603ev:
1615 return "603ev";
1616 case CPU_SUBTYPE_POWERPC_604:
1617 return "604";
1618 case CPU_SUBTYPE_POWERPC_604e:
1619 return "604e";
1620 case CPU_SUBTYPE_POWERPC_620:
1621 return "620";
1622 case CPU_SUBTYPE_POWERPC_750:
1623 return "750";
1624 case CPU_SUBTYPE_POWERPC_7400:
1625 return "7400";
1626 case CPU_SUBTYPE_POWERPC_7450:
1627 return "7450";
1628 case CPU_SUBTYPE_POWERPC_970:
1629 return "970";
1630 default:;
1631 }
1632
1633 return "generic";
1634}
1635#elif defined(__linux__) && defined(__powerpc__)
1636StringRef sys::getHostCPUName() {
1637 std::unique_ptr<llvm::MemoryBuffer> P = getProcCpuinfoContent();
1638 StringRef Content = P ? P->getBuffer() : "";
1639 return detail::getHostCPUNameForPowerPC(Content);
1640}
1641#elif defined(__linux__) && (defined(__arm__) || defined(__aarch64__))
1642StringRef sys::getHostCPUName() {
1643 std::unique_ptr<llvm::MemoryBuffer> P = getProcCpuinfoContent();
1644 StringRef Content = P ? P->getBuffer() : "";
1645 return detail::getHostCPUNameForARM(Content);
1646}
1647#elif defined(__linux__) && defined(__s390x__)
1648StringRef sys::getHostCPUName() {
1649 std::unique_ptr<llvm::MemoryBuffer> P = getProcCpuinfoContent();
1650 StringRef Content = P ? P->getBuffer() : "";
1651 return detail::getHostCPUNameForS390x(Content);
1652}
1653#elif defined(__MVS__)
1654StringRef sys::getHostCPUName() {
1655 // Get pointer to Communications Vector Table (CVT).
1656 // The pointer is located at offset 16 of the Prefixed Save Area (PSA).
1657 // It is stored as 31 bit pointer and will be zero-extended to 64 bit.
1658 int *StartToCVTOffset = reinterpret_cast<int *>(0x10);
1659 // Since its stored as a 31-bit pointer, get the 4 bytes from the start
1660 // of address.
1661 int ReadValue = *StartToCVTOffset;
1662 // Explicitly clear the high order bit.
1663 ReadValue = (ReadValue & 0x7FFFFFFF);
1664 char *CVT = reinterpret_cast<char *>(ReadValue);
1665 // The model number is located in the CVT prefix at offset -6 and stored as
1666 // signless packed decimal.
1667 uint16_t Id = *(uint16_t *)&CVT[-6];
1668 // Convert number to integer.
1669 Id = decodePackedBCD<uint16_t>(Id, false);
1670 // Check for vector support. It's stored in field CVTFLAG5 (offset 244),
1671 // bit CVTVEF (X'80'). The facilities list is part of the PSA but the vector
1672 // extension can only be used if bit CVTVEF is on.
1673 bool HaveVectorSupport = CVT[244] & 0x80;
1674 return getCPUNameFromS390Model(Id, HaveVectorSupport);
1675}
1676#elif defined(__APPLE__) && (defined(__arm__) || defined(__aarch64__))
1677// Copied from <mach/machine.h> in the macOS SDK.
1678//
1679// Also available here, though usually not as up-to-date:
1680// https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.41.3/osfmk/mach/machine.h#L403-L452.
1681#define CPUFAMILY_UNKNOWN 0
1682#define CPUFAMILY_ARM_9 0xe73283ae
1683#define CPUFAMILY_ARM_11 0x8ff620d8
1684#define CPUFAMILY_ARM_XSCALE 0x53b005f5
1685#define CPUFAMILY_ARM_12 0xbd1b0ae9
1686#define CPUFAMILY_ARM_13 0x0cc90e64
1687#define CPUFAMILY_ARM_14 0x96077ef1
1688#define CPUFAMILY_ARM_15 0xa8511bca
1689#define CPUFAMILY_ARM_SWIFT 0x1e2d6381
1690#define CPUFAMILY_ARM_CYCLONE 0x37a09642
1691#define CPUFAMILY_ARM_TYPHOON 0x2c91a47e
1692#define CPUFAMILY_ARM_TWISTER 0x92fb37c8
1693#define CPUFAMILY_ARM_HURRICANE 0x67ceee93
1694#define CPUFAMILY_ARM_MONSOON_MISTRAL 0xe81e7ef6
1695#define CPUFAMILY_ARM_VORTEX_TEMPEST 0x07d34b9f
1696#define CPUFAMILY_ARM_LIGHTNING_THUNDER 0x462504d2
1697#define CPUFAMILY_ARM_FIRESTORM_ICESTORM 0x1b588bb3
1698#define CPUFAMILY_ARM_BLIZZARD_AVALANCHE 0xda33d83d
1699#define CPUFAMILY_ARM_EVEREST_SAWTOOTH 0x8765edea
1700#define CPUFAMILY_ARM_IBIZA 0xfa33415e
1701#define CPUFAMILY_ARM_PALMA 0x72015832
1702#define CPUFAMILY_ARM_COLL 0x2876f5b5
1703#define CPUFAMILY_ARM_LOBOS 0x5f4dea93
1704#define CPUFAMILY_ARM_DONAN 0x6f5129ac
1705#define CPUFAMILY_ARM_BRAVA 0x17d5b93a
1706#define CPUFAMILY_ARM_TAHITI 0x75d4acb9
1707#define CPUFAMILY_ARM_TUPAI 0x204526d0
1708
1709StringRef sys::getHostCPUName() {
1710 uint32_t Family;
1711 size_t Length = sizeof(Family);
1712 sysctlbyname("hw.cpufamily", &Family, &Length, NULL, 0);
1713
1714 // This is found by testing on actual hardware, and by looking at:
1715 // https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.41.3/osfmk/arm/cpuid.c#L109-L231.
1716 //
1717 // Another great resource is
1718 // https://github.com/AsahiLinux/docs/wiki/Codenames.
1719 //
1720 // NOTE: We choose to return `apple-mX` instead of `apple-aX`, since the M1,
1721 // M2, M3 etc. aliases are more widely known to users than A14, A15, A16 etc.
1722 // (and this code is basically only used on host macOS anyways).
1723 switch (Family) {
1724 case CPUFAMILY_UNKNOWN:
1725 return "generic";
1726 case CPUFAMILY_ARM_9:
1727 return "arm920t"; // or arm926ej-s
1728 case CPUFAMILY_ARM_11:
1729 return "arm1136jf-s";
1730 case CPUFAMILY_ARM_XSCALE:
1731 return "xscale";
1732 case CPUFAMILY_ARM_12: // Seems unused by the kernel
1733 return "generic";
1734 case CPUFAMILY_ARM_13:
1735 return "cortex-a8";
1736 case CPUFAMILY_ARM_14:
1737 return "cortex-a9";
1738 case CPUFAMILY_ARM_15:
1739 return "cortex-a7";
1740 case CPUFAMILY_ARM_SWIFT:
1741 return "swift";
1742 case CPUFAMILY_ARM_CYCLONE:
1743 return "apple-a7";
1744 case CPUFAMILY_ARM_TYPHOON:
1745 return "apple-a8";
1746 case CPUFAMILY_ARM_TWISTER:
1747 return "apple-a9";
1748 case CPUFAMILY_ARM_HURRICANE:
1749 return "apple-a10";
1750 case CPUFAMILY_ARM_MONSOON_MISTRAL:
1751 return "apple-a11";
1752 case CPUFAMILY_ARM_VORTEX_TEMPEST:
1753 return "apple-a12";
1754 case CPUFAMILY_ARM_LIGHTNING_THUNDER:
1755 return "apple-a13";
1756 case CPUFAMILY_ARM_FIRESTORM_ICESTORM: // A14 / M1
1757 return "apple-m1";
1758 case CPUFAMILY_ARM_BLIZZARD_AVALANCHE: // A15 / M2
1759 return "apple-m2";
1760 case CPUFAMILY_ARM_EVEREST_SAWTOOTH: // A16
1761 case CPUFAMILY_ARM_IBIZA: // M3
1762 case CPUFAMILY_ARM_PALMA: // M3 Max
1763 case CPUFAMILY_ARM_LOBOS: // M3 Pro
1764 return "apple-m3";
1765 case CPUFAMILY_ARM_COLL: // A17 Pro
1766 return "apple-a17";
1767 case CPUFAMILY_ARM_DONAN: // M4
1768 case CPUFAMILY_ARM_BRAVA: // M4 Max
1769 case CPUFAMILY_ARM_TAHITI: // A18 Pro
1770 case CPUFAMILY_ARM_TUPAI: // A18
1771 return "apple-m4";
1772 default:
1773 // Default to the newest CPU we know about.
1774 return "apple-m4";
1775 }
1776}
1777#elif defined(_AIX)
1778StringRef sys::getHostCPUName() {
1779 switch (_system_configuration.implementation) {
1780 case POWER_4:
1781 if (_system_configuration.version == PV_4_3)
1782 return "970";
1783 return "pwr4";
1784 case POWER_5:
1785 if (_system_configuration.version == PV_5)
1786 return "pwr5";
1787 return "pwr5x";
1788 case POWER_6:
1789 if (_system_configuration.version == PV_6_Compat)
1790 return "pwr6";
1791 return "pwr6x";
1792 case POWER_7:
1793 return "pwr7";
1794 case POWER_8:
1795 return "pwr8";
1796 case POWER_9:
1797 return "pwr9";
1798// TODO: simplify this once the macro is available in all OS levels.
1799#ifdef POWER_10
1800 case POWER_10:
1801#else
1802 case 0x40000:
1803#endif
1804 return "pwr10";
1805#ifdef POWER_11
1806 case POWER_11:
1807#else
1808 case 0x80000:
1809#endif
1810 return "pwr11";
1811 default:
1812 return "generic";
1813 }
1814}
1815#elif defined(__loongarch__)
1816StringRef sys::getHostCPUName() {
1817 // Use processor id to detect cpu name.
1818 uint32_t processor_id;
1819 __asm__("cpucfg %[prid], $zero\n\t" : [prid] "=r"(processor_id));
1820 // Refer PRID_SERIES_MASK in linux kernel: arch/loongarch/include/asm/cpu.h.
1821 switch (processor_id & 0xf000) {
1822 case 0xc000: // Loongson 64bit, 4-issue
1823 return "la464";
1824 case 0xd000: // Loongson 64bit, 6-issue
1825 return "la664";
1826 // TODO: Others.
1827 default:
1828 break;
1829 }
1830 return "generic";
1831}
1832#elif defined(__riscv)
1833#if defined(__linux__)
1834// struct riscv_hwprobe
1835struct RISCVHwProbe {
1836 int64_t Key;
1837 uint64_t Value;
1838};
1839#endif
1840
1841StringRef sys::getHostCPUName() {
1842#if defined(__linux__)
1843 // Try the hwprobe way first.
1844 RISCVHwProbe Query[]{{/*RISCV_HWPROBE_KEY_MVENDORID=*/0, 0},
1845 {/*RISCV_HWPROBE_KEY_MARCHID=*/1, 0},
1846 {/*RISCV_HWPROBE_KEY_MIMPID=*/2, 0}};
1847 int Ret = syscall(/*__NR_riscv_hwprobe=*/258, /*pairs=*/Query,
1848 /*pair_count=*/std::size(Query), /*cpu_count=*/0,
1849 /*cpus=*/0, /*flags=*/0);
1850 if (Ret == 0) {
1851 RISCV::CPUModel Model{static_cast<uint32_t>(Query[0].Value), Query[1].Value,
1852 Query[2].Value};
1853 StringRef Name = RISCV::getCPUNameFromCPUModel(Model);
1854 if (!Name.empty())
1855 return Name;
1856 }
1857
1858 // Then try the cpuinfo way.
1859 std::unique_ptr<llvm::MemoryBuffer> P = getProcCpuinfoContent();
1860 StringRef Content = P ? P->getBuffer() : "";
1861 StringRef Name = detail::getHostCPUNameForRISCV(Content);
1862 if (!Name.empty())
1863 return Name;
1864#endif
1865#if __riscv_xlen == 64
1866 return "generic-rv64";
1867#elif __riscv_xlen == 32
1868 return "generic-rv32";
1869#else
1870#error "Unhandled value of __riscv_xlen"
1871#endif
1872}
1873#elif defined(__sparc__)
1874#if defined(__linux__)
1875StringRef sys::detail::getHostCPUNameForSPARC(StringRef ProcCpuinfoContent) {
1876 SmallVector<StringRef> Lines;
1877 ProcCpuinfoContent.split(Lines, '\n');
1878
1879 // Look for cpu line to determine cpu name
1880 StringRef Cpu;
1881 for (unsigned I = 0, E = Lines.size(); I != E; ++I) {
1882 if (Lines[I].starts_with("cpu")) {
1883 Cpu = Lines[I].substr(5).ltrim("\t :");
1884 break;
1885 }
1886 }
1887
1888 return StringSwitch<const char *>(Cpu)
1889 .StartsWith("SuperSparc", "supersparc")
1890 .StartsWith("HyperSparc", "hypersparc")
1891 .StartsWith("SpitFire", "ultrasparc")
1892 .StartsWith("BlackBird", "ultrasparc")
1893 .StartsWith("Sabre", " ultrasparc")
1894 .StartsWith("Hummingbird", "ultrasparc")
1895 .StartsWith("Cheetah", "ultrasparc3")
1896 .StartsWith("Jalapeno", "ultrasparc3")
1897 .StartsWith("Jaguar", "ultrasparc3")
1898 .StartsWith("Panther", "ultrasparc3")
1899 .StartsWith("Serrano", "ultrasparc3")
1900 .StartsWith("UltraSparc T1", "niagara")
1901 .StartsWith("UltraSparc T2", "niagara2")
1902 .StartsWith("UltraSparc T3", "niagara3")
1903 .StartsWith("UltraSparc T4", "niagara4")
1904 .StartsWith("UltraSparc T5", "niagara4")
1905 .StartsWith("LEON", "leon3")
1906 // niagara7/m8 not supported by LLVM yet.
1907 .StartsWith("SPARC-M7", "niagara4" /* "niagara7" */)
1908 .StartsWith("SPARC-S7", "niagara4" /* "niagara7" */)
1909 .StartsWith("SPARC-M8", "niagara4" /* "m8" */)
1910 .Default("generic");
1911}
1912#endif
1913
1914StringRef sys::getHostCPUName() {
1915#if defined(__linux__)
1916 std::unique_ptr<llvm::MemoryBuffer> P = getProcCpuinfoContent();
1917 StringRef Content = P ? P->getBuffer() : "";
1918 return detail::getHostCPUNameForSPARC(Content);
1919#elif defined(__sun__) && defined(__svr4__)
1920 char *buf = NULL;
1921 kstat_ctl_t *kc;
1922 kstat_t *ksp;
1923 kstat_named_t *brand = NULL;
1924
1925 kc = kstat_open();
1926 if (kc != NULL) {
1927 ksp = kstat_lookup(kc, const_cast<char *>("cpu_info"), -1, NULL);
1928 if (ksp != NULL && kstat_read(kc, ksp, NULL) != -1 &&
1929 ksp->ks_type == KSTAT_TYPE_NAMED)
1930 brand =
1931 (kstat_named_t *)kstat_data_lookup(ksp, const_cast<char *>("brand"));
1932 if (brand != NULL && brand->data_type == KSTAT_DATA_STRING)
1933 buf = KSTAT_NAMED_STR_PTR(brand);
1934 }
1935 kstat_close(kc);
1936
1937 return StringSwitch<const char *>(buf)
1938 .Case("TMS390S10", "supersparc") // Texas Instruments microSPARC I
1939 .Case("TMS390Z50", "supersparc") // Texas Instruments SuperSPARC I
1940 .Case("TMS390Z55",
1941 "supersparc") // Texas Instruments SuperSPARC I with SuperCache
1942 .Case("MB86904", "supersparc") // Fujitsu microSPARC II
1943 .Case("MB86907", "supersparc") // Fujitsu TurboSPARC
1944 .Case("RT623", "hypersparc") // Ross hyperSPARC
1945 .Case("RT625", "hypersparc")
1946 .Case("RT626", "hypersparc")
1947 .Case("UltraSPARC-I", "ultrasparc")
1948 .Case("UltraSPARC-II", "ultrasparc")
1949 .Case("UltraSPARC-IIe", "ultrasparc")
1950 .Case("UltraSPARC-IIi", "ultrasparc")
1951 .Case("SPARC64-III", "ultrasparc")
1952 .Case("SPARC64-IV", "ultrasparc")
1953 .Case("UltraSPARC-III", "ultrasparc3")
1954 .Case("UltraSPARC-III+", "ultrasparc3")
1955 .Case("UltraSPARC-IIIi", "ultrasparc3")
1956 .Case("UltraSPARC-IIIi+", "ultrasparc3")
1957 .Case("UltraSPARC-IV", "ultrasparc3")
1958 .Case("UltraSPARC-IV+", "ultrasparc3")
1959 .Case("SPARC64-V", "ultrasparc3")
1960 .Case("SPARC64-VI", "ultrasparc3")
1961 .Case("SPARC64-VII", "ultrasparc3")
1962 .Case("UltraSPARC-T1", "niagara")
1963 .Case("UltraSPARC-T2", "niagara2")
1964 .Case("UltraSPARC-T2", "niagara2")
1965 .Case("UltraSPARC-T2+", "niagara2")
1966 .Case("SPARC-T3", "niagara3")
1967 .Case("SPARC-T4", "niagara4")
1968 .Case("SPARC-T5", "niagara4")
1969 // niagara7/m8 not supported by LLVM yet.
1970 .Case("SPARC-M7", "niagara4" /* "niagara7" */)
1971 .Case("SPARC-S7", "niagara4" /* "niagara7" */)
1972 .Case("SPARC-M8", "niagara4" /* "m8" */)
1973 .Default("generic");
1974#else
1975 return "generic";
1976#endif
1977}
1978#else
1979StringRef sys::getHostCPUName() { return "generic"; }
1980namespace llvm {
1981namespace sys {
1982namespace detail {
1983namespace x86 {
1984
1985VendorSignatures getVendorSignature(unsigned *MaxLeaf) {
1986 return VendorSignatures::UNKNOWN;
1987}
1988
1989} // namespace x86
1990} // namespace detail
1991} // namespace sys
1992} // namespace llvm
1993#endif
1994
1995#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || \
1996 defined(_M_X64)) && \
1997 !defined(_M_ARM64EC)
1998StringMap<bool> sys::getHostCPUFeatures() {
1999 unsigned EAX = 0, EBX = 0, ECX = 0, EDX = 0;
2000 unsigned MaxLevel;
2001 StringMap<bool> Features;
2002
2003 if (getX86CpuIDAndInfo(0, &MaxLevel, &EBX, &ECX, &EDX) || MaxLevel < 1)
2004 return Features;
2005
2006 getX86CpuIDAndInfo(1, &EAX, &EBX, &ECX, &EDX);
2007
2008 Features["cx8"] = (EDX >> 8) & 1;
2009 Features["cmov"] = (EDX >> 15) & 1;
2010 Features["mmx"] = (EDX >> 23) & 1;
2011 Features["fxsr"] = (EDX >> 24) & 1;
2012 Features["sse"] = (EDX >> 25) & 1;
2013 Features["sse2"] = (EDX >> 26) & 1;
2014
2015 Features["sse3"] = (ECX >> 0) & 1;
2016 Features["pclmul"] = (ECX >> 1) & 1;
2017 Features["ssse3"] = (ECX >> 9) & 1;
2018 Features["cx16"] = (ECX >> 13) & 1;
2019 Features["sse4.1"] = (ECX >> 19) & 1;
2020 Features["sse4.2"] = (ECX >> 20) & 1;
2021 Features["crc32"] = Features["sse4.2"];
2022 Features["movbe"] = (ECX >> 22) & 1;
2023 Features["popcnt"] = (ECX >> 23) & 1;
2024 Features["aes"] = (ECX >> 25) & 1;
2025 Features["rdrnd"] = (ECX >> 30) & 1;
2026
2027 // If CPUID indicates support for XSAVE, XRESTORE and AVX, and XGETBV
2028 // indicates that the AVX registers will be saved and restored on context
2029 // switch, then we have full AVX support.
2030 bool HasXSave = ((ECX >> 27) & 1) && !getX86XCR0(&EAX, &EDX);
2031 bool HasAVXSave = HasXSave && ((ECX >> 28) & 1) && ((EAX & 0x6) == 0x6);
2032#if defined(__APPLE__)
2033 // Darwin lazily saves the AVX512 context on first use: trust that the OS will
2034 // save the AVX512 context if we use AVX512 instructions, even the bit is not
2035 // set right now.
2036 bool HasAVX512Save = true;
2037#else
2038 // AVX512 requires additional context to be saved by the OS.
2039 bool HasAVX512Save = HasAVXSave && ((EAX & 0xe0) == 0xe0);
2040#endif
2041 // AMX requires additional context to be saved by the OS.
2042 const unsigned AMXBits = (1 << 17) | (1 << 18);
2043 bool HasAMXSave = HasXSave && ((EAX & AMXBits) == AMXBits);
2044 // APX requires additional context to be saved by the OS.
2045 bool HasAPXSave = HasXSave && ((EAX >> 19) & 1);
2046
2047 Features["avx"] = HasAVXSave;
2048 Features["fma"] = ((ECX >> 12) & 1) && HasAVXSave;
2049 // Only enable XSAVE if OS has enabled support for saving YMM state.
2050 Features["xsave"] = ((ECX >> 26) & 1) && HasAVXSave;
2051 Features["f16c"] = ((ECX >> 29) & 1) && HasAVXSave;
2052
2053 unsigned MaxExtLevel;
2054 getX86CpuIDAndInfo(0x80000000, &MaxExtLevel, &EBX, &ECX, &EDX);
2055
2056 bool HasExtLeaf1 = MaxExtLevel >= 0x80000001 &&
2057 !getX86CpuIDAndInfo(0x80000001, &EAX, &EBX, &ECX, &EDX);
2058 Features["sahf"] = HasExtLeaf1 && ((ECX >> 0) & 1);
2059 Features["lzcnt"] = HasExtLeaf1 && ((ECX >> 5) & 1);
2060 Features["sse4a"] = HasExtLeaf1 && ((ECX >> 6) & 1);
2061 Features["prfchw"] = HasExtLeaf1 && ((ECX >> 8) & 1);
2062 Features["xop"] = HasExtLeaf1 && ((ECX >> 11) & 1) && HasAVXSave;
2063 Features["lwp"] = HasExtLeaf1 && ((ECX >> 15) & 1);
2064 Features["fma4"] = HasExtLeaf1 && ((ECX >> 16) & 1) && HasAVXSave;
2065 Features["tbm"] = HasExtLeaf1 && ((ECX >> 21) & 1);
2066 Features["mwaitx"] = HasExtLeaf1 && ((ECX >> 29) & 1);
2067
2068 Features["64bit"] = HasExtLeaf1 && ((EDX >> 29) & 1);
2069
2070 // Miscellaneous memory related features, detected by
2071 // using the 0x80000008 leaf of the CPUID instruction
2072 bool HasExtLeaf8 = MaxExtLevel >= 0x80000008 &&
2073 !getX86CpuIDAndInfo(0x80000008, &EAX, &EBX, &ECX, &EDX);
2074 Features["clzero"] = HasExtLeaf8 && ((EBX >> 0) & 1);
2075 Features["rdpru"] = HasExtLeaf8 && ((EBX >> 4) & 1);
2076 Features["wbnoinvd"] = HasExtLeaf8 && ((EBX >> 9) & 1);
2077
2078 bool HasExtLeaf21 = MaxExtLevel >= 0x80000021 &&
2079 !getX86CpuIDAndInfo(0x80000021, &EAX, &EBX, &ECX, &EDX);
2080 // AMD cpuid bit for prefetchi is different from Intel
2081 Features["prefetchi"] = HasExtLeaf21 && ((EAX >> 20) & 1);
2082
2083 bool HasLeaf7 =
2084 MaxLevel >= 7 && !getX86CpuIDAndInfoEx(0x7, 0x0, &EAX, &EBX, &ECX, &EDX);
2085
2086 Features["fsgsbase"] = HasLeaf7 && ((EBX >> 0) & 1);
2087 Features["sgx"] = HasLeaf7 && ((EBX >> 2) & 1);
2088 Features["bmi"] = HasLeaf7 && ((EBX >> 3) & 1);
2089 // AVX2 is only supported if we have the OS save support from AVX.
2090 Features["avx2"] = HasLeaf7 && ((EBX >> 5) & 1) && HasAVXSave;
2091 Features["bmi2"] = HasLeaf7 && ((EBX >> 8) & 1);
2092 Features["invpcid"] = HasLeaf7 && ((EBX >> 10) & 1);
2093 Features["rtm"] = HasLeaf7 && ((EBX >> 11) & 1);
2094 // AVX512 is only supported if the OS supports the context save for it.
2095 Features["avx512f"] = HasLeaf7 && ((EBX >> 16) & 1) && HasAVX512Save;
2096 Features["avx512dq"] = HasLeaf7 && ((EBX >> 17) & 1) && HasAVX512Save;
2097 Features["rdseed"] = HasLeaf7 && ((EBX >> 18) & 1);
2098 Features["adx"] = HasLeaf7 && ((EBX >> 19) & 1);
2099 Features["avx512ifma"] = HasLeaf7 && ((EBX >> 21) & 1) && HasAVX512Save;
2100 Features["clflushopt"] = HasLeaf7 && ((EBX >> 23) & 1);
2101 Features["clwb"] = HasLeaf7 && ((EBX >> 24) & 1);
2102 Features["avx512cd"] = HasLeaf7 && ((EBX >> 28) & 1) && HasAVX512Save;
2103 Features["sha"] = HasLeaf7 && ((EBX >> 29) & 1);
2104 Features["avx512bw"] = HasLeaf7 && ((EBX >> 30) & 1) && HasAVX512Save;
2105 Features["avx512vl"] = HasLeaf7 && ((EBX >> 31) & 1) && HasAVX512Save;
2106
2107 Features["avx512vbmi"] = HasLeaf7 && ((ECX >> 1) & 1) && HasAVX512Save;
2108 Features["pku"] = HasLeaf7 && ((ECX >> 4) & 1);
2109 Features["waitpkg"] = HasLeaf7 && ((ECX >> 5) & 1);
2110 Features["avx512vbmi2"] = HasLeaf7 && ((ECX >> 6) & 1) && HasAVX512Save;
2111 Features["shstk"] = HasLeaf7 && ((ECX >> 7) & 1);
2112 Features["gfni"] = HasLeaf7 && ((ECX >> 8) & 1);
2113 Features["vaes"] = HasLeaf7 && ((ECX >> 9) & 1) && HasAVXSave;
2114 Features["vpclmulqdq"] = HasLeaf7 && ((ECX >> 10) & 1) && HasAVXSave;
2115 Features["avx512vnni"] = HasLeaf7 && ((ECX >> 11) & 1) && HasAVX512Save;
2116 Features["avx512bitalg"] = HasLeaf7 && ((ECX >> 12) & 1) && HasAVX512Save;
2117 Features["avx512vpopcntdq"] = HasLeaf7 && ((ECX >> 14) & 1) && HasAVX512Save;
2118 Features["rdpid"] = HasLeaf7 && ((ECX >> 22) & 1);
2119 Features["kl"] = HasLeaf7 && ((ECX >> 23) & 1); // key locker
2120 Features["cldemote"] = HasLeaf7 && ((ECX >> 25) & 1);
2121 Features["movdiri"] = HasLeaf7 && ((ECX >> 27) & 1);
2122 Features["movdir64b"] = HasLeaf7 && ((ECX >> 28) & 1);
2123 Features["enqcmd"] = HasLeaf7 && ((ECX >> 29) & 1);
2124
2125 Features["uintr"] = HasLeaf7 && ((EDX >> 5) & 1);
2126 Features["avx512vp2intersect"] =
2127 HasLeaf7 && ((EDX >> 8) & 1) && HasAVX512Save;
2128 Features["serialize"] = HasLeaf7 && ((EDX >> 14) & 1);
2129 Features["tsxldtrk"] = HasLeaf7 && ((EDX >> 16) & 1);
2130 // There are two CPUID leafs which information associated with the pconfig
2131 // instruction:
2132 // EAX=0x7, ECX=0x0 indicates the availability of the instruction (via the 18th
2133 // bit of EDX), while the EAX=0x1b leaf returns information on the
2134 // availability of specific pconfig leafs.
2135 // The target feature here only refers to the the first of these two.
2136 // Users might need to check for the availability of specific pconfig
2137 // leaves using cpuid, since that information is ignored while
2138 // detecting features using the "-march=native" flag.
2139 // For more info, see X86 ISA docs.
2140 Features["pconfig"] = HasLeaf7 && ((EDX >> 18) & 1);
2141 Features["amx-bf16"] = HasLeaf7 && ((EDX >> 22) & 1) && HasAMXSave;
2142 Features["avx512fp16"] = HasLeaf7 && ((EDX >> 23) & 1) && HasAVX512Save;
2143 Features["amx-tile"] = HasLeaf7 && ((EDX >> 24) & 1) && HasAMXSave;
2144 Features["amx-int8"] = HasLeaf7 && ((EDX >> 25) & 1) && HasAMXSave;
2145 // EAX from subleaf 0 is the maximum subleaf supported. Some CPUs don't
2146 // return all 0s for invalid subleaves so check the limit.
2147 bool HasLeaf7Subleaf1 =
2148 HasLeaf7 && EAX >= 1 &&
2149 !getX86CpuIDAndInfoEx(0x7, 0x1, &EAX, &EBX, &ECX, &EDX);
2150 Features["sha512"] = HasLeaf7Subleaf1 && ((EAX >> 0) & 1);
2151 Features["sm3"] = HasLeaf7Subleaf1 && ((EAX >> 1) & 1);
2152 Features["sm4"] = HasLeaf7Subleaf1 && ((EAX >> 2) & 1);
2153 Features["raoint"] = HasLeaf7Subleaf1 && ((EAX >> 3) & 1);
2154 Features["avxvnni"] = HasLeaf7Subleaf1 && ((EAX >> 4) & 1) && HasAVXSave;
2155 Features["avx512bf16"] = HasLeaf7Subleaf1 && ((EAX >> 5) & 1) && HasAVX512Save;
2156 Features["amx-fp16"] = HasLeaf7Subleaf1 && ((EAX >> 21) & 1) && HasAMXSave;
2157 Features["cmpccxadd"] = HasLeaf7Subleaf1 && ((EAX >> 7) & 1);
2158 Features["hreset"] = HasLeaf7Subleaf1 && ((EAX >> 22) & 1);
2159 Features["avxifma"] = HasLeaf7Subleaf1 && ((EAX >> 23) & 1) && HasAVXSave;
2160 Features["movrs"] = HasLeaf7Subleaf1 && ((EAX >> 31) & 1);
2161 Features["avxvnniint8"] = HasLeaf7Subleaf1 && ((EDX >> 4) & 1) && HasAVXSave;
2162 Features["avxneconvert"] = HasLeaf7Subleaf1 && ((EDX >> 5) & 1) && HasAVXSave;
2163 Features["amx-complex"] = HasLeaf7Subleaf1 && ((EDX >> 8) & 1) && HasAMXSave;
2164 Features["avxvnniint16"] = HasLeaf7Subleaf1 && ((EDX >> 10) & 1) && HasAVXSave;
2165 Features["prefetchi"] |= HasLeaf7Subleaf1 && ((EDX >> 14) & 1);
2166 Features["usermsr"] = HasLeaf7Subleaf1 && ((EDX >> 15) & 1);
2167 bool HasAVX10 = HasLeaf7Subleaf1 && ((EDX >> 19) & 1);
2168 bool HasAPXF = HasLeaf7Subleaf1 && ((EDX >> 21) & 1) && HasAPXSave;
2169 Features["egpr"] = HasAPXF;
2170 Features["push2pop2"] = HasAPXF;
2171 Features["ppx"] = HasAPXF;
2172 Features["ndd"] = HasAPXF;
2173 Features["ccmp"] = HasAPXF;
2174 Features["nf"] = HasAPXF;
2175 Features["cf"] = HasAPXF;
2176 Features["zu"] = HasAPXF;
2177
2178 bool HasLeafD = MaxLevel >= 0xd &&
2179 !getX86CpuIDAndInfoEx(0xd, 0x1, &EAX, &EBX, &ECX, &EDX);
2180
2181 // Only enable XSAVE if OS has enabled support for saving YMM state.
2182 Features["xsaveopt"] = HasLeafD && ((EAX >> 0) & 1) && HasAVXSave;
2183 Features["xsavec"] = HasLeafD && ((EAX >> 1) & 1) && HasAVXSave;
2184 Features["xsaves"] = HasLeafD && ((EAX >> 3) & 1) && HasAVXSave;
2185
2186 bool HasLeaf14 = MaxLevel >= 0x14 &&
2187 !getX86CpuIDAndInfoEx(0x14, 0x0, &EAX, &EBX, &ECX, &EDX);
2188
2189 Features["ptwrite"] = HasLeaf14 && ((EBX >> 4) & 1);
2190
2191 bool HasLeaf19 =
2192 MaxLevel >= 0x19 && !getX86CpuIDAndInfo(0x19, &EAX, &EBX, &ECX, &EDX);
2193 Features["widekl"] = HasLeaf7 && HasLeaf19 && ((EBX >> 2) & 1);
2194
2195 bool HasLeaf1E = MaxLevel >= 0x1e &&
2196 !getX86CpuIDAndInfoEx(0x1e, 0x1, &EAX, &EBX, &ECX, &EDX);
2197 Features["amx-fp8"] = HasLeaf1E && ((EAX >> 4) & 1) && HasAMXSave;
2198 Features["amx-tf32"] = HasLeaf1E && ((EAX >> 6) & 1) && HasAMXSave;
2199 Features["amx-avx512"] = HasLeaf1E && ((EAX >> 7) & 1) && HasAMXSave;
2200 Features["amx-movrs"] = HasLeaf1E && ((EAX >> 8) & 1) && HasAMXSave;
2201
2202 bool HasLeaf24 = MaxLevel >= 0x24 &&
2203 !getX86CpuIDAndInfoEx(0x24, 0x0, &EAX, &EBX, &ECX, &EDX);
2204
2205 int AVX10Ver = HasLeaf24 ? (EBX & 0xff) : 0;
2206 Features["avx10.1"] = HasAVX10 && AVX10Ver >= 1;
2207 Features["avx10.2"] = HasAVX10 && AVX10Ver >= 2;
2208
2209 return Features;
2210}
2211#elif defined(__linux__) && (defined(__arm__) || defined(__aarch64__))
2212StringMap<bool> sys::getHostCPUFeatures() {
2213 StringMap<bool> Features;
2214 std::unique_ptr<llvm::MemoryBuffer> P = getProcCpuinfoContent();
2215 if (!P)
2216 return Features;
2217
2218 SmallVector<StringRef, 32> Lines;
2219 P->getBuffer().split(Lines, '\n');
2220
2221 SmallVector<StringRef, 32> CPUFeatures;
2222
2223 // Look for the CPU features.
2224 for (unsigned I = 0, E = Lines.size(); I != E; ++I)
2225 if (Lines[I].starts_with("Features")) {
2226 Lines[I].split(CPUFeatures, ' ');
2227 break;
2228 }
2229
2230#if defined(__aarch64__)
2231 // All of these are "crypto" features, but we must sift out actual features
2232 // as the former meaning of "crypto" as a single feature is no more.
2233 enum { CAP_AES = 0x1, CAP_PMULL = 0x2, CAP_SHA1 = 0x4, CAP_SHA2 = 0x8 };
2234 uint32_t crypto = 0;
2235#endif
2236
2237 for (unsigned I = 0, E = CPUFeatures.size(); I != E; ++I) {
2238 StringRef LLVMFeatureStr = StringSwitch<StringRef>(CPUFeatures[I])
2239#if defined(__aarch64__)
2240 .Case("asimd", "neon")
2241 .Case("fp", "fp-armv8")
2242 .Case("crc32", "crc")
2243 .Case("atomics", "lse")
2244 .Case("sha3", "sha3")
2245 .Case("sm4", "sm4")
2246 .Case("sve", "sve")
2247 .Case("sve2", "sve2")
2248 .Case("sveaes", "sve-aes")
2249 .Case("svesha3", "sve-sha3")
2250 .Case("svesm4", "sve-sm4")
2251#else
2252 .Case("half", "fp16")
2253 .Case("neon", "neon")
2254 .Case("vfpv3", "vfp3")
2255 .Case("vfpv3d16", "vfp3d16")
2256 .Case("vfpv4", "vfp4")
2257 .Case("idiva", "hwdiv-arm")
2258 .Case("idivt", "hwdiv")
2259#endif
2260 .Default("");
2261
2262#if defined(__aarch64__)
2263 // We need to check crypto separately since we need all of the crypto
2264 // extensions to enable the subtarget feature
2265 if (CPUFeatures[I] == "aes")
2266 crypto |= CAP_AES;
2267 else if (CPUFeatures[I] == "pmull")
2268 crypto |= CAP_PMULL;
2269 else if (CPUFeatures[I] == "sha1")
2270 crypto |= CAP_SHA1;
2271 else if (CPUFeatures[I] == "sha2")
2272 crypto |= CAP_SHA2;
2273#endif
2274
2275 if (LLVMFeatureStr != "")
2276 Features[LLVMFeatureStr] = true;
2277 }
2278
2279#if defined(__aarch64__)
2280 // LLVM has decided some AArch64 CPUs have all the instructions they _may_
2281 // have, as opposed to all the instructions they _must_ have, so allow runtime
2282 // information to correct us on that.
2283 uint32_t Aes = CAP_AES | CAP_PMULL;
2284 uint32_t Sha2 = CAP_SHA1 | CAP_SHA2;
2285 Features["aes"] = (crypto & Aes) == Aes;
2286 Features["sha2"] = (crypto & Sha2) == Sha2;
2287
2288 // Even if an underlying core supports SVE, it might not be available if
2289 // it's disabled by the OS, or some other layer. Disable SVE if we don't
2290 // detect support at runtime.
2291 if (!Features.contains("sve"))
2292 Features["sve"] = false;
2293#endif
2294
2295 return Features;
2296}
2297#elif defined(_WIN32) && (defined(__aarch64__) || defined(_M_ARM64) || \
2298 defined(__arm64ec__) || defined(_M_ARM64EC))
2299#ifndef PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE
2300#define PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE 43
2301#endif
2302#ifndef PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE
2303#define PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE 44
2304#endif
2305#ifndef PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE
2306#define PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE 45
2307#endif
2308#ifndef PF_ARM_SVE_INSTRUCTIONS_AVAILABLE
2309#define PF_ARM_SVE_INSTRUCTIONS_AVAILABLE 46
2310#endif
2311#ifndef PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE
2312#define PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE 47
2313#endif
2314#ifndef PF_ARM_SVE2_1_INSTRUCTIONS_AVAILABLE
2315#define PF_ARM_SVE2_1_INSTRUCTIONS_AVAILABLE 48
2316#endif
2317#ifndef PF_ARM_SVE_PMULL128_INSTRUCTIONS_AVAILABLE
2318#define PF_ARM_SVE_PMULL128_INSTRUCTIONS_AVAILABLE 50
2319#endif
2320#ifndef PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE
2321#define PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE 51
2322#endif
2323#ifndef PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE
2324#define PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE 55
2325#endif
2326#ifndef PF_ARM_SVE_SM4_INSTRUCTIONS_AVAILABLE
2327#define PF_ARM_SVE_SM4_INSTRUCTIONS_AVAILABLE 56
2328#endif
2329#ifndef PF_ARM_SVE_F32MM_INSTRUCTIONS_AVAILABLE
2330#define PF_ARM_SVE_F32MM_INSTRUCTIONS_AVAILABLE 58
2331#endif
2332#ifndef PF_ARM_SVE_F64MM_INSTRUCTIONS_AVAILABLE
2333#define PF_ARM_SVE_F64MM_INSTRUCTIONS_AVAILABLE 59
2334#endif
2335#ifndef PF_ARM_V82_I8MM_INSTRUCTIONS_AVAILABLE
2336#define PF_ARM_V82_I8MM_INSTRUCTIONS_AVAILABLE 66
2337#endif
2338#ifndef PF_ARM_V82_FP16_INSTRUCTIONS_AVAILABLE
2339#define PF_ARM_V82_FP16_INSTRUCTIONS_AVAILABLE 67
2340#endif
2341#ifndef PF_ARM_V86_BF16_INSTRUCTIONS_AVAILABLE
2342#define PF_ARM_V86_BF16_INSTRUCTIONS_AVAILABLE 68
2343#endif
2344#ifndef PF_ARM_SME_INSTRUCTIONS_AVAILABLE
2345#define PF_ARM_SME_INSTRUCTIONS_AVAILABLE 70
2346#endif
2347#ifndef PF_ARM_SME2_INSTRUCTIONS_AVAILABLE
2348#define PF_ARM_SME2_INSTRUCTIONS_AVAILABLE 71
2349#endif
2350#ifndef PF_ARM_SME_F64F64_INSTRUCTIONS_AVAILABLE
2351#define PF_ARM_SME_F64F64_INSTRUCTIONS_AVAILABLE 85
2352#endif
2353#ifndef PF_ARM_SME_I16I64_INSTRUCTIONS_AVAILABLE
2354#define PF_ARM_SME_I16I64_INSTRUCTIONS_AVAILABLE 86
2355#endif
2356
2357StringMap<bool> sys::getHostCPUFeatures() {
2358 StringMap<bool> Features;
2359
2360 // If we're asking the OS at runtime, believe what the OS says
2361 Features["crc"] =
2362 IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE);
2363 Features["lse"] =
2364 IsProcessorFeaturePresent(PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE);
2365 Features["dotprod"] =
2366 IsProcessorFeaturePresent(PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE);
2367 Features["jsconv"] =
2368 IsProcessorFeaturePresent(PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE);
2369 Features["rcpc"] =
2370 IsProcessorFeaturePresent(PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE);
2371 Features["sve"] =
2372 IsProcessorFeaturePresent(PF_ARM_SVE_INSTRUCTIONS_AVAILABLE);
2373 Features["sve2"] =
2374 IsProcessorFeaturePresent(PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE);
2375 Features["sve2p1"] =
2376 IsProcessorFeaturePresent(PF_ARM_SVE2_1_INSTRUCTIONS_AVAILABLE);
2377 Features["sve-aes"] =
2378 IsProcessorFeaturePresent(PF_ARM_SVE_PMULL128_INSTRUCTIONS_AVAILABLE);
2379 Features["sve-bitperm"] =
2380 IsProcessorFeaturePresent(PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE);
2381 Features["sve-sha3"] =
2382 IsProcessorFeaturePresent(PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE);
2383 Features["sve-sm4"] =
2384 IsProcessorFeaturePresent(PF_ARM_SVE_SM4_INSTRUCTIONS_AVAILABLE);
2385 Features["f32mm"] =
2386 IsProcessorFeaturePresent(PF_ARM_SVE_F32MM_INSTRUCTIONS_AVAILABLE);
2387 Features["f64mm"] =
2388 IsProcessorFeaturePresent(PF_ARM_SVE_F64MM_INSTRUCTIONS_AVAILABLE);
2389 Features["i8mm"] =
2390 IsProcessorFeaturePresent(PF_ARM_V82_I8MM_INSTRUCTIONS_AVAILABLE);
2391 Features["fp16"] =
2392 IsProcessorFeaturePresent(PF_ARM_V82_FP16_INSTRUCTIONS_AVAILABLE);
2393 Features["bf16"] =
2394 IsProcessorFeaturePresent(PF_ARM_V86_BF16_INSTRUCTIONS_AVAILABLE);
2395 Features["sme"] =
2396 IsProcessorFeaturePresent(PF_ARM_SME_INSTRUCTIONS_AVAILABLE);
2397 Features["sme2"] =
2398 IsProcessorFeaturePresent(PF_ARM_SME2_INSTRUCTIONS_AVAILABLE);
2399 Features["sme-i16i64"] =
2400 IsProcessorFeaturePresent(PF_ARM_SME_I16I64_INSTRUCTIONS_AVAILABLE);
2401 Features["sme-f64f64"] =
2402 IsProcessorFeaturePresent(PF_ARM_SME_F64F64_INSTRUCTIONS_AVAILABLE);
2403
2404 // Avoid inferring "crypto" means more than the traditional AES + SHA2
2405 bool TradCrypto =
2406 IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE);
2407 Features["aes"] = TradCrypto;
2408 Features["sha2"] = TradCrypto;
2409
2410 return Features;
2411}
2412#elif defined(__linux__) && defined(__loongarch__)
2413#include <sys/auxv.h>
2414StringMap<bool> sys::getHostCPUFeatures() {
2415 unsigned long hwcap = getauxval(AT_HWCAP);
2416 bool HasFPU = hwcap & (1UL << 3); // HWCAP_LOONGARCH_FPU
2417 uint32_t cpucfg2 = 0x2, cpucfg3 = 0x3;
2418 __asm__("cpucfg %[cpucfg2], %[cpucfg2]\n\t" : [cpucfg2] "+r"(cpucfg2));
2419 __asm__("cpucfg %[cpucfg3], %[cpucfg3]\n\t" : [cpucfg3] "+r"(cpucfg3));
2420
2421 StringMap<bool> Features;
2422
2423 Features["f"] = HasFPU && (cpucfg2 & (1U << 1)); // CPUCFG.2.FP_SP
2424 Features["d"] = HasFPU && (cpucfg2 & (1U << 2)); // CPUCFG.2.FP_DP
2425
2426 Features["lsx"] = hwcap & (1UL << 4); // HWCAP_LOONGARCH_LSX
2427 Features["lasx"] = hwcap & (1UL << 5); // HWCAP_LOONGARCH_LASX
2428 Features["lvz"] = hwcap & (1UL << 9); // HWCAP_LOONGARCH_LVZ
2429
2430 Features["frecipe"] = cpucfg2 & (1U << 25); // CPUCFG.2.FRECIPE
2431 Features["div32"] = cpucfg2 & (1U << 26); // CPUCFG.2.DIV32
2432 Features["lam-bh"] = cpucfg2 & (1U << 27); // CPUCFG.2.LAM_BH
2433 Features["lamcas"] = cpucfg2 & (1U << 28); // CPUCFG.2.LAMCAS
2434 Features["scq"] = cpucfg2 & (1U << 30); // CPUCFG.2.SCQ
2435
2436 Features["ld-seq-sa"] = cpucfg3 & (1U << 23); // CPUCFG.3.LD_SEQ_SA
2437
2438 // TODO: Need to complete.
2439 // Features["llacq-screl"] = cpucfg2 & (1U << 29); // CPUCFG.2.LLACQ_SCREL
2440 return Features;
2441}
2442#elif defined(__linux__) && defined(__riscv)
2443StringMap<bool> sys::getHostCPUFeatures() {
2444 RISCVHwProbe Query[]{{/*RISCV_HWPROBE_KEY_BASE_BEHAVIOR=*/3, 0},
2445 {/*RISCV_HWPROBE_KEY_IMA_EXT_0=*/4, 0},
2446 {/*RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF=*/9, 0}};
2447 int Ret = syscall(/*__NR_riscv_hwprobe=*/258, /*pairs=*/Query,
2448 /*pair_count=*/std::size(Query), /*cpu_count=*/0,
2449 /*cpus=*/0, /*flags=*/0);
2450 if (Ret != 0)
2451 return {};
2452
2453 StringMap<bool> Features;
2454 uint64_t BaseMask = Query[0].Value;
2455 // Check whether RISCV_HWPROBE_BASE_BEHAVIOR_IMA is set.
2456 if (BaseMask & 1) {
2457 Features["i"] = true;
2458 Features["m"] = true;
2459 Features["a"] = true;
2460 }
2461
2462 uint64_t ExtMask = Query[1].Value;
2463 Features["f"] = ExtMask & (1 << 0); // RISCV_HWPROBE_IMA_FD
2464 Features["d"] = ExtMask & (1 << 0); // RISCV_HWPROBE_IMA_FD
2465 Features["c"] = ExtMask & (1 << 1); // RISCV_HWPROBE_IMA_C
2466 Features["v"] = ExtMask & (1 << 2); // RISCV_HWPROBE_IMA_V
2467 Features["zba"] = ExtMask & (1 << 3); // RISCV_HWPROBE_EXT_ZBA
2468 Features["zbb"] = ExtMask & (1 << 4); // RISCV_HWPROBE_EXT_ZBB
2469 Features["zbs"] = ExtMask & (1 << 5); // RISCV_HWPROBE_EXT_ZBS
2470 Features["zicboz"] = ExtMask & (1 << 6); // RISCV_HWPROBE_EXT_ZICBOZ
2471 Features["zbc"] = ExtMask & (1 << 7); // RISCV_HWPROBE_EXT_ZBC
2472 Features["zbkb"] = ExtMask & (1 << 8); // RISCV_HWPROBE_EXT_ZBKB
2473 Features["zbkc"] = ExtMask & (1 << 9); // RISCV_HWPROBE_EXT_ZBKC
2474 Features["zbkx"] = ExtMask & (1 << 10); // RISCV_HWPROBE_EXT_ZBKX
2475 Features["zknd"] = ExtMask & (1 << 11); // RISCV_HWPROBE_EXT_ZKND
2476 Features["zkne"] = ExtMask & (1 << 12); // RISCV_HWPROBE_EXT_ZKNE
2477 Features["zknh"] = ExtMask & (1 << 13); // RISCV_HWPROBE_EXT_ZKNH
2478 Features["zksed"] = ExtMask & (1 << 14); // RISCV_HWPROBE_EXT_ZKSED
2479 Features["zksh"] = ExtMask & (1 << 15); // RISCV_HWPROBE_EXT_ZKSH
2480 Features["zkt"] = ExtMask & (1 << 16); // RISCV_HWPROBE_EXT_ZKT
2481 Features["zvbb"] = ExtMask & (1 << 17); // RISCV_HWPROBE_EXT_ZVBB
2482 Features["zvbc"] = ExtMask & (1 << 18); // RISCV_HWPROBE_EXT_ZVBC
2483 Features["zvkb"] = ExtMask & (1 << 19); // RISCV_HWPROBE_EXT_ZVKB
2484 Features["zvkg"] = ExtMask & (1 << 20); // RISCV_HWPROBE_EXT_ZVKG
2485 Features["zvkned"] = ExtMask & (1 << 21); // RISCV_HWPROBE_EXT_ZVKNED
2486 Features["zvknha"] = ExtMask & (1 << 22); // RISCV_HWPROBE_EXT_ZVKNHA
2487 Features["zvknhb"] = ExtMask & (1 << 23); // RISCV_HWPROBE_EXT_ZVKNHB
2488 Features["zvksed"] = ExtMask & (1 << 24); // RISCV_HWPROBE_EXT_ZVKSED
2489 Features["zvksh"] = ExtMask & (1 << 25); // RISCV_HWPROBE_EXT_ZVKSH
2490 Features["zvkt"] = ExtMask & (1 << 26); // RISCV_HWPROBE_EXT_ZVKT
2491 Features["zfh"] = ExtMask & (1 << 27); // RISCV_HWPROBE_EXT_ZFH
2492 Features["zfhmin"] = ExtMask & (1 << 28); // RISCV_HWPROBE_EXT_ZFHMIN
2493 Features["zihintntl"] = ExtMask & (1 << 29); // RISCV_HWPROBE_EXT_ZIHINTNTL
2494 Features["zvfh"] = ExtMask & (1 << 30); // RISCV_HWPROBE_EXT_ZVFH
2495 Features["zvfhmin"] = ExtMask & (1ULL << 31); // RISCV_HWPROBE_EXT_ZVFHMIN
2496 Features["zfa"] = ExtMask & (1ULL << 32); // RISCV_HWPROBE_EXT_ZFA
2497 Features["ztso"] = ExtMask & (1ULL << 33); // RISCV_HWPROBE_EXT_ZTSO
2498 Features["zacas"] = ExtMask & (1ULL << 34); // RISCV_HWPROBE_EXT_ZACAS
2499 Features["zicond"] = ExtMask & (1ULL << 35); // RISCV_HWPROBE_EXT_ZICOND
2500 Features["zihintpause"] =
2501 ExtMask & (1ULL << 36); // RISCV_HWPROBE_EXT_ZIHINTPAUSE
2502 Features["zve32x"] = ExtMask & (1ULL << 37); // RISCV_HWPROBE_EXT_ZVE32X
2503 Features["zve32f"] = ExtMask & (1ULL << 38); // RISCV_HWPROBE_EXT_ZVE32F
2504 Features["zve64x"] = ExtMask & (1ULL << 39); // RISCV_HWPROBE_EXT_ZVE64X
2505 Features["zve64f"] = ExtMask & (1ULL << 40); // RISCV_HWPROBE_EXT_ZVE64F
2506 Features["zve64d"] = ExtMask & (1ULL << 41); // RISCV_HWPROBE_EXT_ZVE64D
2507 Features["zimop"] = ExtMask & (1ULL << 42); // RISCV_HWPROBE_EXT_ZIMOP
2508 Features["zca"] = ExtMask & (1ULL << 43); // RISCV_HWPROBE_EXT_ZCA
2509 Features["zcb"] = ExtMask & (1ULL << 44); // RISCV_HWPROBE_EXT_ZCB
2510 Features["zcd"] = ExtMask & (1ULL << 45); // RISCV_HWPROBE_EXT_ZCD
2511 Features["zcf"] = ExtMask & (1ULL << 46); // RISCV_HWPROBE_EXT_ZCF
2512 Features["zcmop"] = ExtMask & (1ULL << 47); // RISCV_HWPROBE_EXT_ZCMOP
2513 Features["zawrs"] = ExtMask & (1ULL << 48); // RISCV_HWPROBE_EXT_ZAWRS
2514
2515 // Check whether the processor supports fast misaligned scalar memory access.
2516 // NOTE: RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF is only available on
2517 // Linux 6.11 or later. If it is not recognized, the key field will be cleared
2518 // to -1.
2519 if (Query[2].Key != -1 &&
2520 Query[2].Value == /*RISCV_HWPROBE_MISALIGNED_SCALAR_FAST=*/3)
2521 Features["unaligned-scalar-mem"] = true;
2522
2523 return Features;
2524}
2525#else
2526StringMap<bool> sys::getHostCPUFeatures() { return {}; }
2527#endif
2528
2529#if __APPLE__
2530/// \returns the \p triple, but with the Host's arch spliced in.
2531static Triple withHostArch(Triple T) {
2532#if defined(__arm__)
2533 T.setArch(Triple::arm);
2534 T.setArchName("arm");
2535#elif defined(__arm64e__)
2536 T.setArch(Triple::aarch64, Triple::AArch64SubArch_arm64e);
2537 T.setArchName("arm64e");
2538#elif defined(__aarch64__)
2539 T.setArch(Triple::aarch64);
2540 T.setArchName("arm64");
2541#elif defined(__x86_64h__)
2542 T.setArch(Triple::x86_64);
2543 T.setArchName("x86_64h");
2544#elif defined(__x86_64__)
2545 T.setArch(Triple::x86_64);
2546 T.setArchName("x86_64");
2547#elif defined(__i386__)
2548 T.setArch(Triple::x86);
2549 T.setArchName("i386");
2550#elif defined(__powerpc__)
2551 T.setArch(Triple::ppc);
2552 T.setArchName("powerpc");
2553#else
2554# error "Unimplemented host arch fixup"
2555#endif
2556 return T;
2557}
2558#endif
2559
2560std::string sys::getProcessTriple() {
2561 std::string TargetTripleString = updateTripleOSVersion(LLVM_HOST_TRIPLE);
2562 Triple PT(Triple::normalize(TargetTripleString));
2563
2564#if __APPLE__
2565 /// In Universal builds, LLVM_HOST_TRIPLE will have the wrong arch in one of
2566 /// the slices. This fixes that up.
2567 PT = withHostArch(PT);
2568#endif
2569
2570 if (sizeof(void *) == 8 && PT.isArch32Bit())
2571 PT = PT.get64BitArchVariant();
2572 if (sizeof(void *) == 4 && PT.isArch64Bit())
2573 PT = PT.get32BitArchVariant();
2574
2575 return PT.str();
2576}
2577
2578void sys::printDefaultTargetAndDetectedCPU(raw_ostream &OS) {
2579#if LLVM_VERSION_PRINTER_SHOW_HOST_TARGET_INFO
2580 std::string CPU = std::string(sys::getHostCPUName());
2581 if (CPU == "generic")
2582 CPU = "(unknown)";
2583 OS << " Default target: " << sys::getDefaultTargetTriple() << '\n'
2584 << " Host CPU: " << CPU << '\n';
2585#endif
2586}
StringMap.h
This file defines the StringMap class.
Bitfields.h
This file implements methods to test, set and extract typed bits from packed unsigned integers.
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
getHostCPUNameForARMFromComponents
StringRef getHostCPUNameForARMFromComponents(StringRef Implementer, StringRef Hardware, StringRef Part, ArrayRef< StringRef > Parts, function_ref< unsigned()> GetVariant)
Definition Host.cpp:174
getProcCpuinfoContent
static std::unique_ptr< llvm::MemoryBuffer > getProcCpuinfoContent()
Definition Host.cpp:74
F
#define F(x, y, z)
Definition MD5.cpp:54
I
#define I(x, y, z)
Definition MD5.cpp:57
memcmp
Merge contiguous icmps into a memcmp
Definition MergeICmps.cpp:957
T
#define T
Definition Mips16ISelLowering.cpp:282
P
#define P(N)
SmallVector.h
This file defines the SmallVector class.
StringExtras.h
This file contains some functions that are useful when dealing with strings.
StringSwitch.h
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
starts_with
DEMANGLE_NAMESPACE_BEGIN bool starts_with(std::string_view self, char C) noexcept
Definition StringViewExtras.h:24
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition ArrayRef.h:142
llvm::ErrorOr
Represents either an error or a value T.
Definition ErrorOr.h:56
llvm::MemoryBuffer::getFileAsStream
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileAsStream(const Twine &Filename)
Read all of the specified file into a MemoryBuffer as a stream (i.e.
Definition MemoryBuffer.cpp:604
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition SmallVector.h:946
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition SmallVector.h:666
llvm::SmallVectorImpl::erase
iterator erase(const_iterator CI)
Definition SmallVector.h:746
llvm::SmallVectorTemplateBase::push_back
void push_back(const T &Elt)
Definition SmallVector.h:419
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1205
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition StringMap.h:133
llvm::StringMap::contains
bool contains(StringRef Key) const
contains - Return true if the element is in the map, false otherwise.
Definition StringMap.h:280
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
llvm::StringRef::split
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition StringRef.h:712
llvm::StringRef::npos
static constexpr size_t npos
Definition StringRef.h:57
llvm::StringRef::getAsInteger
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition StringRef.h:472
llvm::StringRef::substr
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition StringRef.h:573
llvm::StringRef::begin
iterator begin() const
Definition StringRef.h:112
llvm::StringRef::const_iterator
const char * const_iterator
Definition StringRef.h:60
llvm::StringRef::ltrim
StringRef ltrim(char Char) const
Return string with consecutive Char characters starting from the the left removed.
Definition StringRef.h:802
llvm::StringRef::end
iterator end() const
Definition StringRef.h:114
llvm::StringRef::ends_with
bool ends_with(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition StringRef.h:273
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition StringSwitch.h:47
llvm::StringSwitch::Case
StringSwitch & Case(StringLiteral S, T Value)
Definition StringSwitch.h:69
llvm::StringSwitch::StartsWith
StringSwitch & StartsWith(StringLiteral S, T Value)
Definition StringSwitch.h:81
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:47
llvm::Triple::get32BitArchVariant
LLVM_ABI llvm::Triple get32BitArchVariant() const
Form a triple with a 32-bit variant of the current architecture.
Definition Triple.cpp:1818
llvm::Triple::get64BitArchVariant
LLVM_ABI llvm::Triple get64BitArchVariant() const
Form a triple with a 64-bit variant of the current architecture.
Definition Triple.cpp:1901
llvm::Triple::normalize
static LLVM_ABI std::string normalize(StringRef Str, CanonicalForm Form=CanonicalForm::ANY)
Turn an arbitrary machine specification into the canonical triple form (or something sensible that th...
Definition Triple.cpp:1187
llvm::Triple::str
const std::string & str() const
Definition Triple.h:484
llvm::Triple::isArch64Bit
LLVM_ABI bool isArch64Bit() const
Test whether the architecture is 64-bit.
Definition Triple.cpp:1806
llvm::Triple::AArch64SubArch_arm64e
@ AArch64SubArch_arm64e
Definition Triple.h:154
llvm::Triple::isArch32Bit
LLVM_ABI bool isArch32Bit() const
Test whether the architecture is 32-bit.
Definition Triple.cpp:1810
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
llvm::Value
LLVM Value Representation.
Definition Value.h:75
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition STLFunctionalExtras.h:37
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
uint16_t
uint32_t
uint64_t
uint8_t
llvm::MachO::CPU_SUBTYPE_POWERPC_970
@ CPU_SUBTYPE_POWERPC_970
Definition MachO.h:1697
llvm::MachO::CPU_SUBTYPE_POWERPC_604e
@ CPU_SUBTYPE_POWERPC_604e
Definition MachO.h:1692
llvm::MachO::CPU_SUBTYPE_POWERPC_603e
@ CPU_SUBTYPE_POWERPC_603e
Definition MachO.h:1689
llvm::MachO::CPU_SUBTYPE_POWERPC_7400
@ CPU_SUBTYPE_POWERPC_7400
Definition MachO.h:1695
llvm::MachO::CPU_SUBTYPE_POWERPC_604
@ CPU_SUBTYPE_POWERPC_604
Definition MachO.h:1691
llvm::MachO::CPU_SUBTYPE_POWERPC_750
@ CPU_SUBTYPE_POWERPC_750
Definition MachO.h:1694
llvm::MachO::CPU_SUBTYPE_POWERPC_601
@ CPU_SUBTYPE_POWERPC_601
Definition MachO.h:1686
llvm::MachO::CPU_SUBTYPE_POWERPC_620
@ CPU_SUBTYPE_POWERPC_620
Definition MachO.h:1693
llvm::MachO::CPU_SUBTYPE_POWERPC_603ev
@ CPU_SUBTYPE_POWERPC_603ev
Definition MachO.h:1690
llvm::MachO::CPU_SUBTYPE_POWERPC_603
@ CPU_SUBTYPE_POWERPC_603
Definition MachO.h:1688
llvm::MachO::CPU_SUBTYPE_POWERPC_7450
@ CPU_SUBTYPE_POWERPC_7450
Definition MachO.h:1696
llvm::MachO::CPU_SUBTYPE_POWERPC_602
@ CPU_SUBTYPE_POWERPC_602
Definition MachO.h:1687
llvm::RISCV::getCPUNameFromCPUModel
LLVM_ABI StringRef getCPUNameFromCPUModel(const CPUModel &Model)
Definition RISCVTargetParser.cpp:69
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
Definition MicrosoftDemangle.h:132
llvm::sys::detail::x86
Helper functions to extract CPU details from CPUID on x86.
Definition Host.h:75
llvm::sys::detail::x86::getVendorSignature
LLVM_ABI VendorSignatures getVendorSignature(unsigned *MaxLeaf=nullptr)
Returns the host CPU's vendor.
Definition Host.cpp:1985
llvm::sys::detail::getHostCPUNameForSPARC
LLVM_ABI StringRef getHostCPUNameForSPARC(StringRef ProcCpuinfoContent)
llvm::sys::detail::getHostCPUNameForS390x
LLVM_ABI StringRef getHostCPUNameForS390x(StringRef ProcCpuinfoContent)
Definition Host.cpp:510
llvm::sys::detail::getHostCPUNameForPowerPC
LLVM_ABI StringRef getHostCPUNameForPowerPC(StringRef ProcCpuinfoContent)
Helper functions to extract HostCPUName from /proc/cpuinfo on linux.
Definition Host.cpp:89
llvm::sys::detail::getHostCPUNameForBPF
LLVM_ABI StringRef getHostCPUNameForBPF()
Definition Host.cpp:572
llvm::sys::detail::getHostCPUNameForARM
LLVM_ABI StringRef getHostCPUNameForARM(StringRef ProcCpuinfoContent)
Definition Host.cpp:399
llvm::sys::detail::getHostCPUNameForRISCV
LLVM_ABI StringRef getHostCPUNameForRISCV(StringRef ProcCpuinfoContent)
Definition Host.cpp:551
llvm::sys::getHostCPUFeatures
LLVM_ABI StringMap< bool, MallocAllocator > getHostCPUFeatures()
getHostCPUFeatures - Get the LLVM names for the host CPU features.
Definition Host.cpp:2526
llvm::sys::getHostCPUName
LLVM_ABI StringRef getHostCPUName()
getHostCPUName - Get the LLVM name for the host CPU.
Definition Host.cpp:1979
llvm::sys::printDefaultTargetAndDetectedCPU
LLVM_ABI void printDefaultTargetAndDetectedCPU(raw_ostream &OS)
This is a function compatible with cl::AddExtraVersionPrinter, which adds info about the current targ...
Definition Host.cpp:2578
llvm::sys::getDefaultTargetTriple
LLVM_ABI std::string getDefaultTargetTriple()
getDefaultTargetTriple() - Return the default target triple the compiler has been configured to produ...
llvm::sys::getProcessTriple
LLVM_ABI std::string getProcessTriple()
getProcessTriple() - Return an appropriate target triple for generating code to be loaded into the cu...
Definition Host.cpp:2560
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition Types.h:26
llvm::Length
@ Length
Definition DWP.cpp:532
llvm::Value
FunctionAddr VTableAddr Value
Definition InstrProf.h:137
llvm::utohexstr
std::string utohexstr(uint64_t X, bool LowerCase=false, unsigned Width=0)
Definition StringExtras.h:177
llvm::decodePackedBCD
int64_t decodePackedBCD(const uint8_t *Ptr, size_t ByteLen, bool IsSigned=true)
Definition BCD.h:26
llvm::unique
auto unique(Range &&R, Predicate P)
Definition STLExtras.h:2124
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition STLExtras.h:1634
llvm::Key
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
Definition PassManager.h:667
llvm::errs
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition raw_ostream.cpp:904
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
Definition STLExtras.h:1945
raw_ostream.h
llvm::Bitfield::Element
Describes an element of a Bitfield.
Definition Bitfields.h:176
llvm::Bitfield::get
static Bitfield::Type get(StorageType Packed)
Unpacks the field from the Packed value.
Definition Bitfields.h:207
Generated on for LLVM by doxygen 1.14.0