Debian Codegraph @

llvm-project/llvm/unittests/TargetParser/Host.cpp

raw
1 //========- unittests/Support/Host.cpp - Host.cpp tests --------------========//
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 #include "llvm/TargetParser/Host.h"
10 #include "llvm/ADT/SmallVector.h"
11 #include "llvm/Config/config.h"
12 #include "llvm/Support/FileSystem.h"
13 #include "llvm/Support/Path.h"
14 #include "llvm/Support/Program.h"
15 #include "llvm/Support/Threading.h"
16 #include "llvm/TargetParser/Triple.h"
17
18 #include "gtest/gtest.h"
19
20 #define ASSERT_NO_ERROR(x) \
21 if (std::error_code ASSERT_NO_ERROR_ec = x) { \
22 SmallString<128> MessageStorage; \
23 raw_svector_ostream Message(MessageStorage); \
24 Message << #x ": did not return errc::success.\n" \
25 << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n" \
26 << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \
27 GTEST_FATAL_FAILURE_(MessageStorage.c_str()); \
28 } else { \
29 }
30
31 using namespace llvm;
32
33 TEST(getLinuxHostCPUName, ARM) {
34 StringRef CortexA9ProcCpuinfo = R"(
35 processor : 0
36 model name : ARMv7 Processor rev 10 (v7l)
37 BogoMIPS : 1393.66
38 Features : half thumb fastmult vfp edsp thumbee neon vfpv3 tls vfpd32
39 CPU implementer : 0x41
40 CPU architecture: 7
41 CPU variant : 0x2
42 CPU part : 0xc09
43 CPU revision : 10
44
45 processor : 1
46 model name : ARMv7 Processor rev 10 (v7l)
47 BogoMIPS : 1393.66
48 Features : half thumb fastmult vfp edsp thumbee neon vfpv3 tls vfpd32
49 CPU implementer : 0x41
50 CPU architecture: 7
51 CPU variant : 0x2
52 CPU part : 0xc09
53 CPU revision : 10
54
55 Hardware : Generic OMAP4 (Flattened Device Tree)
56 Revision : 0000
57 Serial : 0000000000000000
58 )";
59
60 EXPECT_EQ(sys::detail::getHostCPUNameForARM(CortexA9ProcCpuinfo),
61 "cortex-a9");
62 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
63 "CPU part : 0xc0f"),
64 "cortex-a15");
65 // Verify that both CPU implementer and CPU part are checked:
66 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x40\n"
67 "CPU part : 0xc0f"),
68 "generic");
69 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
70 "CPU part : 0x06f"),
71 "krait");
72 }
73
74 TEST(getLinuxHostCPUName, AArch64) {
75 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
76 "CPU part : 0xd03"),
77 "cortex-a53");
78 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
79 "CPU part : 0xd05"),
80 "cortex-a55");
81
82 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
83 "CPU part : 0xd40"),
84 "neoverse-v1");
85 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
86 "CPU part : 0xd0c"),
87 "neoverse-n1");
88 // Verify that both CPU implementer and CPU part are checked:
89 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x40\n"
90 "CPU part : 0xd03"),
91 "generic");
92 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
93 "CPU part : 0x201"),
94 "kryo");
95 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
96 "CPU part : 0x800"),
97 "cortex-a73");
98 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
99 "CPU part : 0x801"),
100 "cortex-a73");
101 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
102 "CPU part : 0xd46"),
103 "cortex-a510");
104 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
105 "CPU part : 0xd47"),
106 "cortex-a710");
107 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
108 "CPU part : 0xd48"),
109 "cortex-x2");
110 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
111 "CPU part : 0xc00"),
112 "falkor");
113 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
114 "CPU part : 0xc01"),
115 "saphira");
116
117 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0xc0\n"
118 "CPU part : 0xac3"),
119 "ampere1");
120 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0xc0\n"
121 "CPU part : 0xac4"),
122 "ampere1a");
123
124 // MSM8992/4 weirdness
125 StringRef MSM8992ProcCpuInfo = R"(
126 Processor : AArch64 Processor rev 3 (aarch64)
127 processor : 0
128 processor : 1
129 processor : 2
130 processor : 3
131 processor : 4
132 processor : 5
133 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32
134 CPU implementer : 0x41
135 CPU architecture: 8
136 CPU variant : 0x0
137 CPU part : 0xd03
138 CPU revision : 3
139
140 Hardware : Qualcomm Technologies, Inc MSM8992
141 )";
142
143 EXPECT_EQ(sys::detail::getHostCPUNameForARM(MSM8992ProcCpuInfo),
144 "cortex-a53");
145
146 // Exynos big.LITTLE weirdness
147 const std::string ExynosProcCpuInfo = R"(
148 processor : 0
149 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32
150 CPU implementer : 0x41
151 CPU architecture: 8
152 CPU variant : 0x0
153 CPU part : 0xd05
154
155 processor : 1
156 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32
157 CPU implementer : 0x53
158 CPU architecture: 8
159 )";
160
161 // Verify default for Exynos.
162 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ExynosProcCpuInfo +
163 "CPU variant : 0xc\n"
164 "CPU part : 0xafe"),
165 "exynos-m3");
166 // Verify Exynos M3.
167 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ExynosProcCpuInfo +
168 "CPU variant : 0x1\n"
169 "CPU part : 0x002"),
170 "exynos-m3");
171 // Verify Exynos M4.
172 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ExynosProcCpuInfo +
173 "CPU variant : 0x1\n"
174 "CPU part : 0x003"),
175 "exynos-m4");
176
177 const std::string ThunderX2T99ProcCpuInfo = R"(
178 processor : 0
179 BogoMIPS : 400.00
180 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32 atomics
181 CPU implementer : 0x43
182 CPU architecture: 8
183 CPU variant : 0x1
184 CPU part : 0x0af
185 )";
186
187 // Verify different versions of ThunderX2T99.
188 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
189 "CPU implementer : 0x42\n"
190 "CPU part : 0x516"),
191 "thunderx2t99");
192
193 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
194 "CPU implementer : 0x42\n"
195 "CPU part : 0x0516"),
196 "thunderx2t99");
197
198 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
199 "CPU implementer : 0x43\n"
200 "CPU part : 0x516"),
201 "thunderx2t99");
202
203 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
204 "CPU implementer : 0x43\n"
205 "CPU part : 0x0516"),
206 "thunderx2t99");
207
208 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
209 "CPU implementer : 0x42\n"
210 "CPU part : 0xaf"),
211 "thunderx2t99");
212
213 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
214 "CPU implementer : 0x42\n"
215 "CPU part : 0x0af"),
216 "thunderx2t99");
217
218 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
219 "CPU implementer : 0x43\n"
220 "CPU part : 0xaf"),
221 "thunderx2t99");
222
223 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
224 "CPU implementer : 0x43\n"
225 "CPU part : 0x0af"),
226 "thunderx2t99");
227
228 // Verify ThunderXT88.
229 const std::string ThunderXT88ProcCpuInfo = R"(
230 processor : 0
231 BogoMIPS : 200.00
232 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32
233 CPU implementer : 0x43
234 CPU architecture: 8
235 CPU variant : 0x1
236 CPU part : 0x0a1
237 )";
238
239 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderXT88ProcCpuInfo +
240 "CPU implementer : 0x43\n"
241 "CPU part : 0x0a1"),
242 "thunderxt88");
243
244 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderXT88ProcCpuInfo +
245 "CPU implementer : 0x43\n"
246 "CPU part : 0xa1"),
247 "thunderxt88");
248
249 // Verify HiSilicon processors.
250 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x48\n"
251 "CPU part : 0xd01"),
252 "tsv110");
253
254 // Verify A64FX.
255 const std::string A64FXProcCpuInfo = R"(
256 processor : 0
257 BogoMIPS : 200.00
258 Features : fp asimd evtstrm sha1 sha2 crc32 atomics fphp asimdhp cpuid asimdrdm fcma dcpop sve
259 CPU implementer : 0x46
260 CPU architecture: 8
261 CPU variant : 0x1
262 CPU part : 0x001
263 )";
264
265 EXPECT_EQ(sys::detail::getHostCPUNameForARM(A64FXProcCpuInfo), "a64fx");
266
267 // Verify Nvidia Carmel.
268 const std::string CarmelProcCpuInfo = R"(
269 processor : 0
270 model name : ARMv8 Processor rev 0 (v8l)
271 BogoMIPS : 62.50
272 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32 atomics fphp asimdhp cpuid asimdrdm dcpop
273 CPU implementer : 0x4e
274 CPU architecture: 8
275 CPU variant : 0x0
276 CPU part : 0x004
277 CPU revision : 0
278 )";
279
280 EXPECT_EQ(sys::detail::getHostCPUNameForARM(CarmelProcCpuInfo), "carmel");
281
282 // Snapdragon mixed implementer quirk
283 const std::string Snapdragon865ProcCPUInfo = R"(
284 processor : 0
285 BogoMIPS : 38.40
286 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32 atomics fphp asimdhp cpuid asimdrdm lrcpc dcpop asimddp
287 CPU implementer : 0x51
288 CPU architecture: 8
289 CPU variant : 0xd
290 CPU part : 0x805
291 CPU revision : 14
292 processor : 1
293 processor : 2
294 processor : 3
295 processor : 4
296 processor : 5
297 processor : 6
298 BogoMIPS : 38.40
299 Features : fp asimd evtstrm aes pmull sha1 sha2 crc32 atomics fphp asimdhp cpuid asimdrdm lrcpc dcpop asimddp
300 CPU implementer : 0x41
301 CPU architecture: 8
302 CPU variant : 0x1
303 CPU part : 0xd0d
304 CPU revision : 0
305 )";
306 EXPECT_EQ(sys::detail::getHostCPUNameForARM(Snapdragon865ProcCPUInfo), "cortex-a77");
307 }
308
309 TEST(getLinuxHostCPUName, s390x) {
310 SmallVector<std::string> ModelIDs(
311 {"3931", "8561", "3906", "2964", "2827", "2817", "2097", "2064"});
312 SmallVector<std::string> VectorSupport({"", "vx"});
313 SmallVector<StringRef> ExpectedCPUs;
314
315 // Model Id: 3931
316 ExpectedCPUs.push_back("zEC12");
317 ExpectedCPUs.push_back("z16");
318
319 // Model Id: 8561
320 ExpectedCPUs.push_back("zEC12");
321 ExpectedCPUs.push_back("z15");
322
323 // Model Id: 3906
324 ExpectedCPUs.push_back("zEC12");
325 ExpectedCPUs.push_back("z14");
326
327 // Model Id: 2964
328 ExpectedCPUs.push_back("zEC12");
329 ExpectedCPUs.push_back("z13");
330
331 // Model Id: 2827
332 ExpectedCPUs.push_back("zEC12");
333 ExpectedCPUs.push_back("zEC12");
334
335 // Model Id: 2817
336 ExpectedCPUs.push_back("z196");
337 ExpectedCPUs.push_back("z196");
338
339 // Model Id: 2097
340 ExpectedCPUs.push_back("z10");
341 ExpectedCPUs.push_back("z10");
342
343 // Model Id: 2064
344 ExpectedCPUs.push_back("generic");
345 ExpectedCPUs.push_back("generic");
346
347 const std::string DummyBaseVectorInfo =
348 "features : esan3 zarch stfle msa ldisp eimm dfp edat etf3eh highgprs "
349 "te ";
350 const std::string DummyBaseMachineInfo =
351 "processor 0: version = FF, identification = 059C88, machine = ";
352
353 int CheckIndex = 0;
354 for (size_t I = 0; I < ModelIDs.size(); I++) {
355 for (size_t J = 0; J < VectorSupport.size(); J++) {
356 const std::string DummyCPUInfo = DummyBaseVectorInfo + VectorSupport[J] +
357 "\n" + DummyBaseMachineInfo +
358 ModelIDs[I];
359 EXPECT_EQ(sys::detail::getHostCPUNameForS390x(DummyCPUInfo),
360 ExpectedCPUs[CheckIndex++]);
361 }
362 }
363 }
364
365 TEST(getLinuxHostCPUName, RISCV) {
366 const StringRef SifiveU74MCProcCPUInfo = R"(
367 processor : 0
368 hart : 2
369 isa : rv64imafdc
370 mmu : sv39
371 uarch : sifive,u74-mc
372 )";
373 EXPECT_EQ(sys::detail::getHostCPUNameForRISCV(SifiveU74MCProcCPUInfo),
374 "sifive-u74");
375 EXPECT_EQ(
376 sys::detail::getHostCPUNameForRISCV("uarch : sifive,bullet0\n"),
377 "sifive-u74");
378 }
379
380 static bool runAndGetCommandOutput(
381 const char *ExePath, ArrayRef<llvm::StringRef> argv,
382 std::unique_ptr<char[]> &Buffer, off_t &Size) {
383 bool Success = false;
384 [ExePath, argv, &Buffer, &Size, &Success] {
385 using namespace llvm::sys;
386 SmallString<128> TestDirectory;
387 ASSERT_NO_ERROR(fs::createUniqueDirectory("host_test", TestDirectory));
388
389 SmallString<128> OutputFile(TestDirectory);
390 path::append(OutputFile, "out");
391 StringRef OutputPath = OutputFile.str();
392
393 const std::optional<StringRef> Redirects[] = {
394 /*STDIN=*/std::nullopt, /*STDOUT=*/OutputPath, /*STDERR=*/std::nullopt};
395 int RetCode =
396 ExecuteAndWait(ExePath, argv, /*env=*/std::nullopt, Redirects);
397 ASSERT_EQ(0, RetCode);
398
399 int FD = 0;
400 ASSERT_NO_ERROR(fs::openFileForRead(OutputPath, FD));
401 Size = ::lseek(FD, 0, SEEK_END);
402 ASSERT_NE(-1, Size);
403 ::lseek(FD, 0, SEEK_SET);
404 Buffer = std::make_unique<char[]>(Size);
405 ASSERT_EQ(::read(FD, Buffer.get(), Size), Size);
406 ::close(FD);
407
408 ASSERT_NO_ERROR(fs::remove(OutputPath));
409 ASSERT_NO_ERROR(fs::remove(TestDirectory.str()));
410 Success = true;
411 }();
412 return Success;
413 }
414
415 TEST(HostTest, DummyRunAndGetCommandOutputUse) {
416 // Suppress defined-but-not-used warnings when the tests using the helper are
417 // disabled.
418 (void)&runAndGetCommandOutput;
419 }
420
421 TEST(HostTest, getMacOSHostVersion) {
422 llvm::Triple HostTriple(llvm::sys::getProcessTriple());
423 if (!HostTriple.isMacOSX())
424 GTEST_SKIP();
425
426 const char *SwVersPath = "/usr/bin/sw_vers";
427 StringRef argv[] = {SwVersPath, "-productVersion"};
428 std::unique_ptr<char[]> Buffer;
429 off_t Size;
430 ASSERT_EQ(runAndGetCommandOutput(SwVersPath, argv, Buffer, Size), true);
431 StringRef SystemVersionStr = StringRef(Buffer.get(), Size).rtrim();
432
433 // Ensure that the two versions match.
434 VersionTuple SystemVersion;
435 ASSERT_EQ(llvm::Triple((Twine("x86_64-apple-macos") + SystemVersionStr))
436 .getMacOSXVersion(SystemVersion),
437 true);
438 VersionTuple HostVersion;
439 ASSERT_EQ(HostTriple.getMacOSXVersion(HostVersion), true);
440
441 if (SystemVersion.getMajor() > 10) {
442 // Don't compare the 'Minor' and 'Micro' versions, as they're always '0' for
443 // the 'Darwin' triples on 11.x.
444 ASSERT_EQ(SystemVersion.getMajor(), HostVersion.getMajor());
445 } else {
446 // Don't compare the 'Micro' version, as it's always '0' for the 'Darwin'
447 // triples.
448 ASSERT_EQ(SystemVersion.getMajor(), HostVersion.getMajor());
449 ASSERT_EQ(SystemVersion.getMinor(), HostVersion.getMinor());
450 }
451 }
452
453 // Helper to return AIX system version. Must return void to use ASSERT_*.
454 static void getAIXSystemVersion(VersionTuple &SystemVersion) {
455 const char *ExePath = "/usr/bin/oslevel";
456 StringRef argv[] = {ExePath};
457 std::unique_ptr<char[]> Buffer;
458 off_t Size;
459 ASSERT_EQ(runAndGetCommandOutput(ExePath, argv, Buffer, Size), true);
460 StringRef SystemVersionStr = StringRef(Buffer.get(), Size).rtrim();
461
462 SystemVersion =
463 llvm::Triple((Twine("powerpc-ibm-aix") + SystemVersionStr))
464 .getOSVersion();
465 }
466
467 TEST(HostTest, AIXHostVersionDetect) {
468 llvm::Triple HostTriple(llvm::sys::getProcessTriple());
469 if (HostTriple.getOS() != Triple::AIX)
470 GTEST_SKIP();
471
472 llvm::Triple ConfiguredHostTriple(LLVM_HOST_TRIPLE);
473 ASSERT_EQ(ConfiguredHostTriple.getOS(), Triple::AIX);
474
475 VersionTuple SystemVersion;
476 getAIXSystemVersion(SystemVersion);
477
478 // Ensure that the host triple version (major) and release (minor) numbers,
479 // unless explicitly configured, match with those of the current system.
480 auto SysMajor = SystemVersion.getMajor();
481 auto SysMinor = SystemVersion.getMinor();
482 VersionTuple HostVersion = HostTriple.getOSVersion();
483 if (ConfiguredHostTriple.getOSMajorVersion()) {
484 // Explicitly configured, force a match. We do it this way so the
485 // asserts are always executed.
486 SysMajor = HostVersion.getMajor();
487 SysMinor = HostVersion.getMinor();
488 }
489 ASSERT_EQ(SysMajor, HostVersion.getMajor());
490 ASSERT_EQ(SysMinor, HostVersion.getMinor());
491 }
492
493 TEST(HostTest, AIXTargetVersionDetect) {
494 llvm::Triple TargetTriple(llvm::sys::getDefaultTargetTriple());
495 if (TargetTriple.getOS() != Triple::AIX)
496 GTEST_SKIP();
497
498 // Ensure that the target triple version (major) and release (minor) numbers
499 // match with those of the current system.
500 llvm::Triple ConfiguredTargetTriple(LLVM_DEFAULT_TARGET_TRIPLE);
501 if (ConfiguredTargetTriple.getOSMajorVersion())
502 GTEST_SKIP(); // The version was configured explicitly; skip.
503
504 VersionTuple SystemVersion;
505 getAIXSystemVersion(SystemVersion);
506 VersionTuple TargetVersion = TargetTriple.getOSVersion();
507 ASSERT_EQ(SystemVersion.getMajor(), TargetVersion.getMajor());
508 ASSERT_EQ(SystemVersion.getMinor(), TargetVersion.getMinor());
509 }
510
511 TEST(HostTest, AIXHostCPUDetect) {
512 llvm::Triple HostTriple(llvm::sys::getProcessTriple());
513 if (HostTriple.getOS() != Triple::AIX)
514 GTEST_SKIP();
515
516 // Return a value based on the current processor implementation mode.
517 const char *ExePath = "/usr/sbin/getsystype";
518 StringRef argv[] = {ExePath, "-i"};
519 std::unique_ptr<char[]> Buffer;
520 off_t Size;
521 ASSERT_EQ(runAndGetCommandOutput(ExePath, argv, Buffer, Size), true);
522 StringRef CPU(Buffer.get(), Size);
523 StringRef MCPU = StringSwitch<const char *>(CPU)
524 .Case("POWER 4\n", "pwr4")
525 .Case("POWER 5\n", "pwr5")
526 .Case("POWER 6\n", "pwr6")
527 .Case("POWER 7\n", "pwr7")
528 .Case("POWER 8\n", "pwr8")
529 .Case("POWER 9\n", "pwr9")
530 .Case("POWER 10\n", "pwr10")
531 .Default("unknown");
532
533 StringRef HostCPU = sys::getHostCPUName();
534
535 // Just do the comparison on the base implementation mode.
536 if (HostCPU == "970")
537 HostCPU = StringRef("pwr4");
538 else
539 HostCPU = HostCPU.rtrim('x');
540
541 EXPECT_EQ(HostCPU, MCPU);
542 }