Debian Codegraph @

llvm-project/lldb/unittests/Utility/ArchSpecTest.cpp

raw
1 //===-- ArchSpecTest.cpp --------------------------------------------------===//
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 "gtest/gtest.h"
10
11 #include "lldb/Utility/ArchSpec.h"
12 #include "llvm/BinaryFormat/ELF.h"
13 #include "llvm/BinaryFormat/MachO.h"
14
15 using namespace lldb;
16 using namespace lldb_private;
17
18 TEST(ArchSpecTest, TestParseMachCPUDashSubtypeTripleSimple) {
19
20 // Success conditions. Valid cpu/subtype combinations using both - and .
21 ArchSpec AS;
22 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10", AS));
23 EXPECT_EQ(12u, AS.GetMachOCPUType());
24 EXPECT_EQ(10u, AS.GetMachOCPUSubType());
25
26 AS = ArchSpec();
27 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15", AS));
28 EXPECT_EQ(12u, AS.GetMachOCPUType());
29 EXPECT_EQ(15u, AS.GetMachOCPUSubType());
30
31 AS = ArchSpec();
32 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12.15", AS));
33 EXPECT_EQ(12u, AS.GetMachOCPUType());
34 EXPECT_EQ(15u, AS.GetMachOCPUSubType());
35
36 // Failure conditions.
37
38 // Valid string, unknown cpu/subtype.
39 AS = ArchSpec();
40 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("13.11", AS));
41 EXPECT_EQ(0u, AS.GetMachOCPUType());
42 EXPECT_EQ(0u, AS.GetMachOCPUSubType());
43
44 // Missing / invalid cpu or subtype
45 AS = ArchSpec();
46 EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("13", AS));
47
48 AS = ArchSpec();
49 EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("13.A", AS));
50
51 AS = ArchSpec();
52 EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("A.13", AS));
53
54 // Empty string.
55 AS = ArchSpec();
56 EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("", AS));
57 }
58
59 TEST(ArchSpecTest, TestParseMachCPUDashSubtypeTripleExtra) {
60 ArchSpec AS;
61 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15-vendor-os", AS));
62 EXPECT_EQ(12u, AS.GetMachOCPUType());
63 EXPECT_EQ(15u, AS.GetMachOCPUSubType());
64 EXPECT_EQ("vendor", AS.GetTriple().getVendorName());
65 EXPECT_EQ("os", AS.GetTriple().getOSName());
66
67 AS = ArchSpec();
68 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10-vendor-os-name", AS));
69 EXPECT_EQ(12u, AS.GetMachOCPUType());
70 EXPECT_EQ(10u, AS.GetMachOCPUSubType());
71 EXPECT_EQ("vendor", AS.GetTriple().getVendorName());
72 EXPECT_EQ("os", AS.GetTriple().getOSName());
73
74 AS = ArchSpec();
75 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15-vendor.os-name", AS));
76 EXPECT_EQ(12u, AS.GetMachOCPUType());
77 EXPECT_EQ(15u, AS.GetMachOCPUSubType());
78 EXPECT_EQ("vendor.os", AS.GetTriple().getVendorName());
79 EXPECT_EQ("name", AS.GetTriple().getOSName());
80
81 // These there should parse correctly, but the vendor / OS should be defaulted
82 // since they are unrecognized.
83 AS = ArchSpec();
84 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10-vendor", AS));
85 EXPECT_EQ(12u, AS.GetMachOCPUType());
86 EXPECT_EQ(10u, AS.GetMachOCPUSubType());
87 EXPECT_EQ("apple", AS.GetTriple().getVendorName());
88 EXPECT_EQ("", AS.GetTriple().getOSName());
89
90 AS = ArchSpec();
91 EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("12.10.10", AS));
92
93 AS = ArchSpec();
94 EXPECT_FALSE(ParseMachCPUDashSubtypeTriple("12-10.10", AS));
95 }
96
97 TEST(ArchSpecTest, TestSetTriple) {
98 ArchSpec AS;
99
100 // Various flavors of valid triples.
101 EXPECT_TRUE(AS.SetTriple("12-10-apple-darwin"));
102 EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_ARM), AS.GetMachOCPUType());
103 EXPECT_EQ(10u, AS.GetMachOCPUSubType());
104 EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str())
105 .consume_front("armv7f-apple-darwin"));
106 EXPECT_EQ(ArchSpec::eCore_arm_armv7f, AS.GetCore());
107
108 AS = ArchSpec();
109 EXPECT_TRUE(AS.SetTriple("18.100-apple-darwin"));
110 EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_POWERPC), AS.GetMachOCPUType());
111 EXPECT_EQ(100u, AS.GetMachOCPUSubType());
112 EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str())
113 .consume_front("powerpc-apple-darwin"));
114 EXPECT_EQ(ArchSpec::eCore_ppc_ppc970, AS.GetCore());
115
116 AS = ArchSpec();
117 EXPECT_TRUE(AS.SetTriple("i686-pc-windows"));
118 EXPECT_EQ(llvm::Triple::x86, AS.GetTriple().getArch());
119 EXPECT_EQ(llvm::Triple::PC, AS.GetTriple().getVendor());
120 EXPECT_EQ(llvm::Triple::Win32, AS.GetTriple().getOS());
121 EXPECT_TRUE(
122 llvm::StringRef(AS.GetTriple().str()).consume_front("i686-pc-windows"));
123 EXPECT_STREQ("i686", AS.GetArchitectureName());
124 EXPECT_EQ(ArchSpec::eCore_x86_32_i686, AS.GetCore());
125
126 // Various flavors of invalid triples.
127 AS = ArchSpec();
128 EXPECT_FALSE(AS.SetTriple("unknown-unknown-unknown"));
129
130 AS = ArchSpec();
131 EXPECT_FALSE(AS.SetTriple("unknown"));
132
133 AS = ArchSpec();
134 EXPECT_FALSE(AS.SetTriple(""));
135 }
136
137 TEST(ArchSpecTest, MergeFrom) {
138 {
139 ArchSpec A;
140 ArchSpec B("x86_64-pc-linux");
141
142 EXPECT_FALSE(A.IsValid());
143 ASSERT_TRUE(B.IsValid());
144 EXPECT_EQ(llvm::Triple::ArchType::x86_64, B.GetTriple().getArch());
145 EXPECT_EQ(llvm::Triple::VendorType::PC, B.GetTriple().getVendor());
146 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
147 EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, B.GetCore());
148
149 A.MergeFrom(B);
150 ASSERT_TRUE(A.IsValid());
151 EXPECT_EQ(llvm::Triple::ArchType::x86_64, A.GetTriple().getArch());
152 EXPECT_EQ(llvm::Triple::VendorType::PC, A.GetTriple().getVendor());
153 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
154 EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, A.GetCore());
155 }
156 {
157 ArchSpec A("aarch64");
158 ArchSpec B("aarch64--linux-android");
159
160 ArchSpec C("arm64_32");
161 ArchSpec D("arm64_32--watchos");
162
163 EXPECT_TRUE(A.IsValid());
164 EXPECT_TRUE(B.IsValid());
165 EXPECT_TRUE(C.IsValid());
166 EXPECT_TRUE(D.IsValid());
167
168 EXPECT_EQ(llvm::Triple::ArchType::aarch64, B.GetTriple().getArch());
169 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
170 B.GetTriple().getVendor());
171 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
172 EXPECT_EQ(llvm::Triple::EnvironmentType::Android,
173 B.GetTriple().getEnvironment());
174
175 A.MergeFrom(B);
176 EXPECT_EQ(llvm::Triple::ArchType::aarch64, A.GetTriple().getArch());
177 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
178 A.GetTriple().getVendor());
179 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
180 EXPECT_EQ(llvm::Triple::EnvironmentType::Android,
181 A.GetTriple().getEnvironment());
182
183 EXPECT_EQ(llvm::Triple::ArchType::aarch64_32, D.GetTriple().getArch());
184 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
185 D.GetTriple().getVendor());
186 EXPECT_EQ(llvm::Triple::OSType::WatchOS, D.GetTriple().getOS());
187
188 C.MergeFrom(D);
189 EXPECT_EQ(llvm::Triple::ArchType::aarch64_32, C.GetTriple().getArch());
190 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
191 C.GetTriple().getVendor());
192 EXPECT_EQ(llvm::Triple::OSType::WatchOS, C.GetTriple().getOS());
193 }
194 {
195 ArchSpec A, B;
196 A.SetArchitecture(eArchTypeELF, llvm::ELF::EM_ARM,
197 LLDB_INVALID_CPUTYPE, llvm::ELF::ELFOSABI_NONE);
198 B.SetArchitecture(eArchTypeELF, llvm::ELF::EM_ARM,
199 LLDB_INVALID_CPUTYPE, llvm::ELF::ELFOSABI_LINUX);
200
201 EXPECT_TRUE(A.IsValid());
202 EXPECT_TRUE(B.IsValid());
203
204 EXPECT_EQ(llvm::Triple::ArchType::arm, B.GetTriple().getArch());
205 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
206 B.GetTriple().getVendor());
207 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
208 EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
209 B.GetTriple().getEnvironment());
210
211 A.MergeFrom(B);
212 EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
213 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
214 A.GetTriple().getVendor());
215 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
216 EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
217 A.GetTriple().getEnvironment());
218 }
219 {
220 ArchSpec A("arm--linux-eabihf");
221 ArchSpec B("armv8l--linux-gnueabihf");
222
223 EXPECT_TRUE(A.IsValid());
224 EXPECT_TRUE(B.IsValid());
225
226 EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
227 EXPECT_EQ(llvm::Triple::ArchType::arm, B.GetTriple().getArch());
228
229 EXPECT_EQ(ArchSpec::eCore_arm_generic, A.GetCore());
230 EXPECT_EQ(ArchSpec::eCore_arm_armv8l, B.GetCore());
231
232 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
233 A.GetTriple().getVendor());
234 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
235 B.GetTriple().getVendor());
236
237 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
238 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
239
240 EXPECT_EQ(llvm::Triple::EnvironmentType::EABIHF,
241 A.GetTriple().getEnvironment());
242 EXPECT_EQ(llvm::Triple::EnvironmentType::GNUEABIHF,
243 B.GetTriple().getEnvironment());
244
245 A.MergeFrom(B);
246 EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
247 EXPECT_EQ(ArchSpec::eCore_arm_armv8l, A.GetCore());
248 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
249 A.GetTriple().getVendor());
250 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
251 EXPECT_EQ(llvm::Triple::EnvironmentType::EABIHF,
252 A.GetTriple().getEnvironment());
253 }
254 }
255
256 TEST(ArchSpecTest, MergeFromMachOUnknown) {
257 class MyArchSpec : public ArchSpec {
258 public:
259 MyArchSpec() {
260 this->SetTriple("unknown-mach-64");
261 this->m_core = ArchSpec::eCore_uknownMach64;
262 this->m_byte_order = eByteOrderLittle;
263 this->m_flags = 0;
264 }
265 };
266
267 MyArchSpec A;
268 ASSERT_TRUE(A.IsValid());
269 MyArchSpec B;
270 ASSERT_TRUE(B.IsValid());
271 A.MergeFrom(B);
272 ASSERT_EQ(A.GetCore(), ArchSpec::eCore_uknownMach64);
273 }
274
275 TEST(ArchSpecTest, Compatibility) {
276 {
277 ArchSpec A("x86_64-apple-macosx10.12");
278 ArchSpec B("x86_64-apple-macosx10.12");
279 ASSERT_TRUE(A.IsExactMatch(B));
280 ASSERT_TRUE(A.IsCompatibleMatch(B));
281 }
282 {
283 // The version information is auxiliary to support availability but
284 // doesn't affect compatibility.
285 ArchSpec A("x86_64-apple-macosx10.11");
286 ArchSpec B("x86_64-apple-macosx10.12");
287 ASSERT_TRUE(A.IsExactMatch(B));
288 ASSERT_TRUE(A.IsCompatibleMatch(B));
289 }
290 {
291 ArchSpec A("x86_64-apple-macosx10.13");
292 ArchSpec B("x86_64h-apple-macosx10.13");
293 ASSERT_FALSE(A.IsExactMatch(B));
294 ASSERT_TRUE(A.IsCompatibleMatch(B));
295 }
296 {
297 ArchSpec A("x86_64-apple-macosx");
298 ArchSpec B("x86_64-apple-ios-simulator");
299 ASSERT_FALSE(A.IsExactMatch(B));
300 ASSERT_FALSE(A.IsCompatibleMatch(B));
301 }
302 {
303 ArchSpec A("x86_64-*-*");
304 ArchSpec B("x86_64-apple-ios-simulator");
305 ASSERT_FALSE(A.IsExactMatch(B));
306 ASSERT_FALSE(A.IsCompatibleMatch(B));
307 ASSERT_FALSE(B.IsExactMatch(A));
308 ASSERT_FALSE(B.IsCompatibleMatch(A));
309 }
310 {
311 ArchSpec A("x86_64-apple-ios");
312 ArchSpec B("x86_64-apple-ios-simulator");
313 ASSERT_FALSE(A.IsExactMatch(B));
314 ASSERT_FALSE(A.IsCompatibleMatch(B));
315 ASSERT_FALSE(B.IsExactMatch(A));
316 ASSERT_FALSE(B.IsCompatibleMatch(A));
317 }
318 {
319 // FIXME: This is surprisingly not equivalent to "x86_64-*-*".
320 ArchSpec A("x86_64");
321 ArchSpec B("x86_64-apple-ios-simulator");
322 ASSERT_FALSE(A.IsExactMatch(B));
323 ASSERT_TRUE(A.IsCompatibleMatch(B));
324 ASSERT_FALSE(B.IsExactMatch(A));
325 ASSERT_TRUE(B.IsCompatibleMatch(A));
326 }
327 {
328 ArchSpec A("arm64-apple-ios");
329 ArchSpec B("arm64-apple-ios-simulator");
330 ASSERT_FALSE(A.IsExactMatch(B));
331 ASSERT_FALSE(A.IsCompatibleMatch(B));
332 ASSERT_FALSE(B.IsCompatibleMatch(A));
333 ASSERT_FALSE(B.IsCompatibleMatch(A));
334 }
335 {
336 ArchSpec A("arm64-*-*");
337 ArchSpec B("arm64-apple-ios");
338 ASSERT_FALSE(A.IsExactMatch(B));
339 // FIXME: This looks unintuitive and we should investigate whether
340 // this is the desired behavior.
341 ASSERT_FALSE(A.IsCompatibleMatch(B));
342 }
343 {
344 ArchSpec A("x86_64-*-*");
345 ArchSpec B("x86_64-apple-ios-simulator");
346 ASSERT_FALSE(A.IsExactMatch(B));
347 // FIXME: See above, though the extra environment complicates things.
348 ASSERT_FALSE(A.IsCompatibleMatch(B));
349 }
350 {
351 ArchSpec A("x86_64");
352 ArchSpec B("x86_64-apple-macosx10.14");
353 // FIXME: The exact match also looks unintuitive.
354 ASSERT_TRUE(A.IsExactMatch(B));
355 ASSERT_TRUE(A.IsCompatibleMatch(B));
356 }
357 {
358 ArchSpec A("x86_64");
359 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
360 // FIXME: The exact match also looks unintuitive.
361 ASSERT_TRUE(A.IsExactMatch(B));
362 ASSERT_TRUE(A.IsCompatibleMatch(B));
363 }
364 {
365 ArchSpec A("x86_64-apple-ios12.0.0");
366 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
367 ASSERT_FALSE(A.IsExactMatch(B));
368 ASSERT_FALSE(A.IsCompatibleMatch(B));
369 }
370 {
371 ArchSpec A("x86_64-apple-macosx10.14.2");
372 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
373 ASSERT_FALSE(A.IsExactMatch(B));
374 ASSERT_TRUE(A.IsCompatibleMatch(B));
375 }
376 {
377 ArchSpec A("x86_64-apple-macosx10.14.2");
378 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
379 // ios-macabi wins.
380 A.MergeFrom(B);
381 ASSERT_TRUE(A.IsExactMatch(B));
382 }
383 {
384 ArchSpec A("x86_64-apple-macosx10.14.2");
385 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
386 ArchSpec C(B);
387 // ios-macabi wins.
388 B.MergeFrom(A);
389 ASSERT_TRUE(B.IsExactMatch(C));
390 }
391 }
392
393 TEST(ArchSpecTest, OperatorBool) {
394 EXPECT_FALSE(ArchSpec());
395 EXPECT_TRUE(ArchSpec("x86_64-pc-linux"));
396 }
397
398 TEST(ArchSpecTest, TripleComponentsWereSpecified) {
399 {
400 ArchSpec A("");
401 ArchSpec B("-");
402 ArchSpec C("--");
403 ArchSpec D("---");
404
405 ASSERT_FALSE(A.TripleVendorWasSpecified());
406 ASSERT_FALSE(A.TripleOSWasSpecified());
407 ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
408
409 ASSERT_FALSE(B.TripleVendorWasSpecified());
410 ASSERT_FALSE(B.TripleOSWasSpecified());
411 ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
412
413 ASSERT_FALSE(C.TripleVendorWasSpecified());
414 ASSERT_FALSE(C.TripleOSWasSpecified());
415 ASSERT_FALSE(C.TripleEnvironmentWasSpecified());
416
417 ASSERT_FALSE(D.TripleVendorWasSpecified());
418 ASSERT_FALSE(D.TripleOSWasSpecified());
419 ASSERT_FALSE(D.TripleEnvironmentWasSpecified());
420 }
421 {
422 // TODO: llvm::Triple::normalize treats the missing components from these
423 // triples as specified unknown components instead of unspecified
424 // components. We need to either change the behavior in llvm or work around
425 // this in lldb.
426 ArchSpec A("armv7");
427 ArchSpec B("armv7-");
428 ArchSpec C("armv7--");
429 ArchSpec D("armv7---");
430
431 ASSERT_FALSE(A.TripleVendorWasSpecified());
432 ASSERT_FALSE(A.TripleOSWasSpecified());
433 ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
434
435 ASSERT_TRUE(B.TripleVendorWasSpecified());
436 ASSERT_FALSE(B.TripleOSWasSpecified());
437 ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
438
439 ASSERT_TRUE(C.TripleVendorWasSpecified());
440 ASSERT_TRUE(C.TripleOSWasSpecified());
441 ASSERT_FALSE(C.TripleEnvironmentWasSpecified());
442
443 ASSERT_TRUE(D.TripleVendorWasSpecified());
444 ASSERT_TRUE(D.TripleOSWasSpecified());
445 ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
446 }
447 {
448 ArchSpec A("x86_64-unknown");
449 ArchSpec B("powerpc-unknown-linux");
450 ArchSpec C("i386-pc-windows-msvc");
451 ArchSpec D("aarch64-unknown-linux-android");
452
453 ASSERT_TRUE(A.TripleVendorWasSpecified());
454 ASSERT_FALSE(A.TripleOSWasSpecified());
455 ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
456
457 ASSERT_TRUE(B.TripleVendorWasSpecified());
458 ASSERT_TRUE(B.TripleOSWasSpecified());
459 ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
460
461 ASSERT_TRUE(C.TripleVendorWasSpecified());
462 ASSERT_TRUE(C.TripleOSWasSpecified());
463 ASSERT_TRUE(C.TripleEnvironmentWasSpecified());
464
465 ASSERT_TRUE(D.TripleVendorWasSpecified());
466 ASSERT_TRUE(D.TripleOSWasSpecified());
467 ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
468 }
469 }