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
15using namespace lldb;
16using namespace lldb_private;
17
18TEST(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
59TEST(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
97TEST(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("24-0-apple-unknown"));
118 EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_RISCV), AS.GetMachOCPUType());
119 EXPECT_EQ(0u, AS.GetMachOCPUSubType());
120 EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str())
121 .consume_front("riscv32-apple-unknown"));
122 EXPECT_EQ(ArchSpec::eCore_riscv32, AS.GetCore());
123
124 AS = ArchSpec();
125 EXPECT_TRUE(AS.SetTriple("i686-pc-windows"));
126 EXPECT_EQ(llvm::Triple::x86, AS.GetTriple().getArch());
127 EXPECT_EQ(llvm::Triple::PC, AS.GetTriple().getVendor());
128 EXPECT_EQ(llvm::Triple::Win32, AS.GetTriple().getOS());
129 EXPECT_TRUE(
130 llvm::StringRef(AS.GetTriple().str()).consume_front("i686-pc-windows"));
131 EXPECT_STREQ("i686", AS.GetArchitectureName());
132 EXPECT_EQ(ArchSpec::eCore_x86_32_i686, AS.GetCore());
133
134 AS = ArchSpec();
135 EXPECT_TRUE(AS.SetTriple("msp430---elf"));
136 EXPECT_EQ(llvm::Triple::msp430, AS.GetTriple().getArch());
137 EXPECT_STREQ("msp430", AS.GetArchitectureName());
138 EXPECT_EQ(ArchSpec::eCore_msp430, AS.GetCore());
139
140 AS = ArchSpec();
141 EXPECT_TRUE(AS.SetTriple("amd64-unknown-openbsd"));
142 EXPECT_EQ(llvm::Triple::x86_64, AS.GetTriple().getArch());
143 EXPECT_STREQ("amd64", AS.GetArchitectureName());
144 EXPECT_EQ(ArchSpec::eCore_x86_64_amd64, AS.GetCore());
145
146 // Various flavors of invalid triples.
147 AS = ArchSpec();
148 EXPECT_FALSE(AS.SetTriple("unknown-unknown-unknown"));
149
150 AS = ArchSpec();
151 EXPECT_FALSE(AS.SetTriple("unknown"));
152
153 AS = ArchSpec();
154 EXPECT_FALSE(AS.SetTriple(""));
155}
156
157TEST(ArchSpecTest, MergeFrom) {
158 {
159 ArchSpec A;
160 ArchSpec B("x86_64-pc-linux");
161
162 EXPECT_FALSE(A.IsValid());
163 ASSERT_TRUE(B.IsValid());
164 EXPECT_EQ(llvm::Triple::ArchType::x86_64, B.GetTriple().getArch());
165 EXPECT_EQ(llvm::Triple::VendorType::PC, B.GetTriple().getVendor());
166 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
167 EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, B.GetCore());
168
169 A.MergeFrom(other: B);
170 ASSERT_TRUE(A.IsValid());
171 EXPECT_EQ(llvm::Triple::ArchType::x86_64, A.GetTriple().getArch());
172 EXPECT_EQ(llvm::Triple::VendorType::PC, A.GetTriple().getVendor());
173 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
174 EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, A.GetCore());
175 }
176 {
177 ArchSpec A("aarch64");
178 ArchSpec B("aarch64--linux-android");
179
180 ArchSpec C("arm64_32");
181 ArchSpec D("arm64_32--watchos");
182
183 EXPECT_TRUE(A.IsValid());
184 EXPECT_TRUE(B.IsValid());
185 EXPECT_TRUE(C.IsValid());
186 EXPECT_TRUE(D.IsValid());
187
188 EXPECT_EQ(llvm::Triple::ArchType::aarch64, B.GetTriple().getArch());
189 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
190 B.GetTriple().getVendor());
191 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
192 EXPECT_EQ(llvm::Triple::EnvironmentType::Android,
193 B.GetTriple().getEnvironment());
194
195 A.MergeFrom(other: B);
196 EXPECT_EQ(llvm::Triple::ArchType::aarch64, A.GetTriple().getArch());
197 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
198 A.GetTriple().getVendor());
199 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
200 EXPECT_EQ(llvm::Triple::EnvironmentType::Android,
201 A.GetTriple().getEnvironment());
202
203 EXPECT_EQ(llvm::Triple::ArchType::aarch64_32, D.GetTriple().getArch());
204 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
205 D.GetTriple().getVendor());
206 EXPECT_EQ(llvm::Triple::OSType::WatchOS, D.GetTriple().getOS());
207
208 C.MergeFrom(other: D);
209 EXPECT_EQ(llvm::Triple::ArchType::aarch64_32, C.GetTriple().getArch());
210 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
211 C.GetTriple().getVendor());
212 EXPECT_EQ(llvm::Triple::OSType::WatchOS, C.GetTriple().getOS());
213 }
214 {
215 ArchSpec A, B;
216 A.SetArchitecture(arch_type: eArchTypeELF, cpu: llvm::ELF::EM_ARM,
217 LLDB_INVALID_CPUTYPE, os: llvm::ELF::ELFOSABI_NONE);
218 B.SetArchitecture(arch_type: eArchTypeELF, cpu: llvm::ELF::EM_ARM,
219 LLDB_INVALID_CPUTYPE, os: llvm::ELF::ELFOSABI_LINUX);
220
221 EXPECT_TRUE(A.IsValid());
222 EXPECT_TRUE(B.IsValid());
223
224 EXPECT_EQ(llvm::Triple::ArchType::arm, B.GetTriple().getArch());
225 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
226 B.GetTriple().getVendor());
227 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
228 EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
229 B.GetTriple().getEnvironment());
230
231 A.MergeFrom(other: B);
232 EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
233 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
234 A.GetTriple().getVendor());
235 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
236 EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
237 A.GetTriple().getEnvironment());
238 }
239 {
240 ArchSpec A("arm--linux-eabihf");
241 ArchSpec B("armv8l--linux-gnueabihf");
242
243 EXPECT_TRUE(A.IsValid());
244 EXPECT_TRUE(B.IsValid());
245
246 EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
247 EXPECT_EQ(llvm::Triple::ArchType::arm, B.GetTriple().getArch());
248
249 EXPECT_EQ(ArchSpec::eCore_arm_generic, A.GetCore());
250 EXPECT_EQ(ArchSpec::eCore_arm_armv8l, B.GetCore());
251
252 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
253 A.GetTriple().getVendor());
254 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
255 B.GetTriple().getVendor());
256
257 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
258 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
259
260 EXPECT_EQ(llvm::Triple::EnvironmentType::EABIHF,
261 A.GetTriple().getEnvironment());
262 EXPECT_EQ(llvm::Triple::EnvironmentType::GNUEABIHF,
263 B.GetTriple().getEnvironment());
264
265 A.MergeFrom(other: B);
266 EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
267 EXPECT_EQ(ArchSpec::eCore_arm_armv8l, A.GetCore());
268 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
269 A.GetTriple().getVendor());
270 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
271 EXPECT_EQ(llvm::Triple::EnvironmentType::EABIHF,
272 A.GetTriple().getEnvironment());
273 }
274}
275
276TEST(ArchSpecTest, MergeFromMachOUnknown) {
277 class MyArchSpec : public ArchSpec {
278 public:
279 MyArchSpec() {
280 this->SetTriple("unknown-mach-64");
281 this->m_core = ArchSpec::eCore_uknownMach64;
282 this->m_byte_order = eByteOrderLittle;
283 this->m_flags = 0;
284 }
285 };
286
287 MyArchSpec A;
288 ASSERT_TRUE(A.IsValid());
289 MyArchSpec B;
290 ASSERT_TRUE(B.IsValid());
291 A.MergeFrom(other: B);
292 ASSERT_EQ(A.GetCore(), ArchSpec::eCore_uknownMach64);
293}
294
295TEST(ArchSpecTest, Compatibility) {
296 {
297 ArchSpec A("x86_64-apple-macosx10.12");
298 ArchSpec B("x86_64-apple-macosx10.12");
299 ASSERT_TRUE(A.IsExactMatch(B));
300 ASSERT_TRUE(A.IsCompatibleMatch(B));
301 }
302 {
303 // The version information is auxiliary to support availability but
304 // doesn't affect compatibility.
305 ArchSpec A("x86_64-apple-macosx10.11");
306 ArchSpec B("x86_64-apple-macosx10.12");
307 ASSERT_TRUE(A.IsExactMatch(B));
308 ASSERT_TRUE(A.IsCompatibleMatch(B));
309 }
310 {
311 ArchSpec A("x86_64-apple-macosx10.13");
312 ArchSpec B("x86_64h-apple-macosx10.13");
313 ASSERT_FALSE(A.IsExactMatch(B));
314 ASSERT_TRUE(A.IsCompatibleMatch(B));
315 }
316 {
317 ArchSpec A("x86_64-apple-macosx");
318 ArchSpec B("x86_64-apple-ios-simulator");
319 ASSERT_FALSE(A.IsExactMatch(B));
320 ASSERT_FALSE(A.IsCompatibleMatch(B));
321 }
322 {
323 ArchSpec A("x86_64-*-*");
324 ArchSpec B("x86_64-apple-ios-simulator");
325 ASSERT_FALSE(A.IsExactMatch(B));
326 ASSERT_FALSE(A.IsCompatibleMatch(B));
327 ASSERT_FALSE(B.IsExactMatch(A));
328 ASSERT_FALSE(B.IsCompatibleMatch(A));
329 }
330 {
331 ArchSpec A("x86_64-apple-ios");
332 ArchSpec B("x86_64-apple-ios-simulator");
333 ASSERT_FALSE(A.IsExactMatch(B));
334 ASSERT_FALSE(A.IsCompatibleMatch(B));
335 ASSERT_FALSE(B.IsExactMatch(A));
336 ASSERT_FALSE(B.IsCompatibleMatch(A));
337 }
338 {
339 // FIXME: This is surprisingly not equivalent to "x86_64-*-*".
340 ArchSpec A("x86_64");
341 ArchSpec B("x86_64-apple-ios-simulator");
342 ASSERT_FALSE(A.IsExactMatch(B));
343 ASSERT_TRUE(A.IsCompatibleMatch(B));
344 ASSERT_FALSE(B.IsExactMatch(A));
345 ASSERT_TRUE(B.IsCompatibleMatch(A));
346 }
347 {
348 ArchSpec A("arm64-apple-ios");
349 ArchSpec B("arm64-apple-ios-simulator");
350 ASSERT_FALSE(A.IsExactMatch(B));
351 ASSERT_FALSE(A.IsCompatibleMatch(B));
352 ASSERT_FALSE(B.IsCompatibleMatch(A));
353 ASSERT_FALSE(B.IsCompatibleMatch(A));
354 }
355 {
356 ArchSpec A("arm64-*-*");
357 ArchSpec B("arm64-apple-ios");
358 ASSERT_FALSE(A.IsExactMatch(B));
359 // FIXME: This looks unintuitive and we should investigate whether
360 // this is the desired behavior.
361 ASSERT_FALSE(A.IsCompatibleMatch(B));
362 }
363 {
364 ArchSpec A("x86_64-*-*");
365 ArchSpec B("x86_64-apple-ios-simulator");
366 ASSERT_FALSE(A.IsExactMatch(B));
367 // FIXME: See above, though the extra environment complicates things.
368 ASSERT_FALSE(A.IsCompatibleMatch(B));
369 }
370 {
371 ArchSpec A("x86_64");
372 ArchSpec B("x86_64-apple-macosx10.14");
373 // FIXME: The exact match also looks unintuitive.
374 ASSERT_TRUE(A.IsExactMatch(B));
375 ASSERT_TRUE(A.IsCompatibleMatch(B));
376 }
377 {
378 ArchSpec A("x86_64");
379 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
380 // FIXME: The exact match also looks unintuitive.
381 ASSERT_TRUE(A.IsExactMatch(B));
382 ASSERT_TRUE(A.IsCompatibleMatch(B));
383 }
384 {
385 ArchSpec A("x86_64-apple-ios12.0.0");
386 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
387 ASSERT_FALSE(A.IsExactMatch(B));
388 ASSERT_FALSE(A.IsCompatibleMatch(B));
389 }
390 {
391 ArchSpec A("x86_64-apple-macosx10.14.2");
392 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
393 ASSERT_FALSE(A.IsExactMatch(B));
394 ASSERT_TRUE(A.IsCompatibleMatch(B));
395 }
396 {
397 ArchSpec A("x86_64-apple-macosx10.14.2");
398 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
399 // ios-macabi wins.
400 A.MergeFrom(other: B);
401 ASSERT_TRUE(A.IsExactMatch(B));
402 }
403 {
404 ArchSpec A("x86_64-apple-macosx10.14.2");
405 ArchSpec B("x86_64-apple-ios12.0.0-macabi");
406 ArchSpec C(B);
407 // ios-macabi wins.
408 B.MergeFrom(other: A);
409 ASSERT_TRUE(B.IsExactMatch(C));
410 }
411 {
412 ArchSpec A("x86_64-apple-driverkit19.0");
413 ArchSpec B("x86_64-apple-macosx10.15.0");
414 ASSERT_FALSE(A.IsExactMatch(B));
415 ASSERT_TRUE(A.IsCompatibleMatch(B));
416 }
417}
418
419TEST(ArchSpecTest, OperatorBool) {
420 EXPECT_FALSE(ArchSpec());
421 EXPECT_TRUE(ArchSpec("x86_64-pc-linux"));
422}
423
424TEST(ArchSpecTest, TripleComponentsWereSpecified) {
425 {
426 ArchSpec A("");
427 ArchSpec B("-");
428 ArchSpec C("--");
429 ArchSpec D("---");
430
431 ASSERT_FALSE(A.TripleVendorWasSpecified());
432 ASSERT_FALSE(A.TripleOSWasSpecified());
433 ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
434
435 ASSERT_FALSE(B.TripleVendorWasSpecified());
436 ASSERT_FALSE(B.TripleOSWasSpecified());
437 ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
438
439 ASSERT_FALSE(C.TripleVendorWasSpecified());
440 ASSERT_FALSE(C.TripleOSWasSpecified());
441 ASSERT_FALSE(C.TripleEnvironmentWasSpecified());
442
443 ASSERT_FALSE(D.TripleVendorWasSpecified());
444 ASSERT_FALSE(D.TripleOSWasSpecified());
445 ASSERT_FALSE(D.TripleEnvironmentWasSpecified());
446 }
447 {
448 // TODO: llvm::Triple::normalize treats the missing components from these
449 // triples as specified unknown components instead of unspecified
450 // components. We need to either change the behavior in llvm or work around
451 // this in lldb.
452 ArchSpec A("armv7");
453 ArchSpec B("armv7-");
454 ArchSpec C("armv7--");
455 ArchSpec D("armv7---");
456
457 ASSERT_FALSE(A.TripleVendorWasSpecified());
458 ASSERT_FALSE(A.TripleOSWasSpecified());
459 ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
460
461 ASSERT_TRUE(B.TripleVendorWasSpecified());
462 ASSERT_FALSE(B.TripleOSWasSpecified());
463 ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
464
465 ASSERT_TRUE(C.TripleVendorWasSpecified());
466 ASSERT_TRUE(C.TripleOSWasSpecified());
467 ASSERT_FALSE(C.TripleEnvironmentWasSpecified());
468
469 ASSERT_TRUE(D.TripleVendorWasSpecified());
470 ASSERT_TRUE(D.TripleOSWasSpecified());
471 ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
472 }
473 {
474 ArchSpec A("x86_64-unknown");
475 ArchSpec B("powerpc-unknown-linux");
476 ArchSpec C("i386-pc-windows-msvc");
477 ArchSpec D("aarch64-unknown-linux-android");
478
479 ASSERT_TRUE(A.TripleVendorWasSpecified());
480 ASSERT_FALSE(A.TripleOSWasSpecified());
481 ASSERT_FALSE(A.TripleEnvironmentWasSpecified());
482
483 ASSERT_TRUE(B.TripleVendorWasSpecified());
484 ASSERT_TRUE(B.TripleOSWasSpecified());
485 ASSERT_FALSE(B.TripleEnvironmentWasSpecified());
486
487 ASSERT_TRUE(C.TripleVendorWasSpecified());
488 ASSERT_TRUE(C.TripleOSWasSpecified());
489 ASSERT_TRUE(C.TripleEnvironmentWasSpecified());
490
491 ASSERT_TRUE(D.TripleVendorWasSpecified());
492 ASSERT_TRUE(D.TripleOSWasSpecified());
493 ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
494 }
495}
496

source code of lldb/unittests/Utility/ArchSpecTest.cpp