1 //===--- Triple.cpp - Target triple helper class --------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/ADT/Triple.h"
11 #include "llvm/ADT/SmallString.h"
12 #include "llvm/ADT/StringSwitch.h"
13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/Support/ErrorHandling.h"
15 #include <cstring>
16 using namespace llvm;
17
getArchTypeName(ArchType Kind)18 const char *Triple::getArchTypeName(ArchType Kind) {
19 switch (Kind) {
20 case UnknownArch: return "unknown";
21
22 case arm: return "arm";
23 case cellspu: return "cellspu";
24 case hexagon: return "hexagon";
25 case mips: return "mips";
26 case mipsel: return "mipsel";
27 case mips64: return "mips64";
28 case mips64el:return "mips64el";
29 case msp430: return "msp430";
30 case ppc64: return "powerpc64";
31 case ppc: return "powerpc";
32 case r600: return "r600";
33 case sparc: return "sparc";
34 case sparcv9: return "sparcv9";
35 case tce: return "tce";
36 case thumb: return "thumb";
37 case x86: return "i386";
38 case x86_64: return "x86_64";
39 case xcore: return "xcore";
40 case mblaze: return "mblaze";
41 case ptx32: return "ptx32";
42 case ptx64: return "ptx64";
43 case le32: return "le32";
44 case amdil: return "amdil";
45 }
46
47 llvm_unreachable("Invalid ArchType!");
48 }
49
getArchTypePrefix(ArchType Kind)50 const char *Triple::getArchTypePrefix(ArchType Kind) {
51 switch (Kind) {
52 default:
53 return 0;
54
55 case arm:
56 case thumb: return "arm";
57
58 case cellspu: return "spu";
59
60 case ppc64:
61 case ppc: return "ppc";
62
63 case mblaze: return "mblaze";
64
65 case hexagon: return "hexagon";
66
67 case r600: return "r600";
68
69 case sparcv9:
70 case sparc: return "sparc";
71
72 case x86:
73 case x86_64: return "x86";
74
75 case xcore: return "xcore";
76
77 case ptx32: return "ptx";
78 case ptx64: return "ptx";
79 case le32: return "le32";
80 case amdil: return "amdil";
81 }
82 }
83
getVendorTypeName(VendorType Kind)84 const char *Triple::getVendorTypeName(VendorType Kind) {
85 switch (Kind) {
86 case UnknownVendor: return "unknown";
87
88 case Apple: return "apple";
89 case PC: return "pc";
90 case SCEI: return "scei";
91 case BGP: return "bgp";
92 case BGQ: return "bgq";
93 }
94
95 llvm_unreachable("Invalid VendorType!");
96 }
97
getOSTypeName(OSType Kind)98 const char *Triple::getOSTypeName(OSType Kind) {
99 switch (Kind) {
100 case UnknownOS: return "unknown";
101
102 case AuroraUX: return "auroraux";
103 case Cygwin: return "cygwin";
104 case Darwin: return "darwin";
105 case DragonFly: return "dragonfly";
106 case FreeBSD: return "freebsd";
107 case IOS: return "ios";
108 case KFreeBSD: return "kfreebsd";
109 case Linux: return "linux";
110 case Lv2: return "lv2";
111 case MacOSX: return "macosx";
112 case MinGW32: return "mingw32";
113 case NetBSD: return "netbsd";
114 case OpenBSD: return "openbsd";
115 case Solaris: return "solaris";
116 case Win32: return "win32";
117 case Haiku: return "haiku";
118 case Minix: return "minix";
119 case RTEMS: return "rtems";
120 case NativeClient: return "nacl";
121 case CNK: return "cnk";
122 }
123
124 llvm_unreachable("Invalid OSType");
125 }
126
getEnvironmentTypeName(EnvironmentType Kind)127 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
128 switch (Kind) {
129 case UnknownEnvironment: return "unknown";
130 case GNU: return "gnu";
131 case GNUEABIHF: return "gnueabihf";
132 case GNUEABI: return "gnueabi";
133 case EABI: return "eabi";
134 case MachO: return "macho";
135 case ANDROIDEABI: return "androideabi";
136 }
137
138 llvm_unreachable("Invalid EnvironmentType!");
139 }
140
getArchTypeForLLVMName(StringRef Name)141 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
142 return StringSwitch<Triple::ArchType>(Name)
143 .Case("arm", arm)
144 .Case("cellspu", cellspu)
145 .Case("mips", mips)
146 .Case("mipsel", mipsel)
147 .Case("mips64", mips64)
148 .Case("mips64el", mips64el)
149 .Case("msp430", msp430)
150 .Case("ppc64", ppc64)
151 .Case("ppc32", ppc)
152 .Case("ppc", ppc)
153 .Case("mblaze", mblaze)
154 .Case("r600", r600)
155 .Case("hexagon", hexagon)
156 .Case("sparc", sparc)
157 .Case("sparcv9", sparcv9)
158 .Case("tce", tce)
159 .Case("thumb", thumb)
160 .Case("x86", x86)
161 .Case("x86-64", x86_64)
162 .Case("xcore", xcore)
163 .Case("ptx32", ptx32)
164 .Case("ptx64", ptx64)
165 .Case("le32", le32)
166 .Case("amdil", amdil)
167 .Default(UnknownArch);
168 }
169
getArchTypeForDarwinArchName(StringRef Str)170 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
171 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
172 // archs which Darwin doesn't use.
173
174 // The matching this routine does is fairly pointless, since it is neither the
175 // complete architecture list, nor a reasonable subset. The problem is that
176 // historically the driver driver accepts this and also ties its -march=
177 // handling to the architecture name, so we need to be careful before removing
178 // support for it.
179
180 // This code must be kept in sync with Clang's Darwin specific argument
181 // translation.
182
183 return StringSwitch<ArchType>(Str)
184 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", Triple::ppc)
185 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", Triple::ppc)
186 .Case("ppc64", Triple::ppc64)
187 .Cases("i386", "i486", "i486SX", "i586", "i686", Triple::x86)
188 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
189 Triple::x86)
190 .Case("x86_64", Triple::x86_64)
191 // This is derived from the driver driver.
192 .Cases("arm", "armv4t", "armv5", "armv6", Triple::arm)
193 .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", Triple::arm)
194 .Case("r600", Triple::r600)
195 .Case("ptx32", Triple::ptx32)
196 .Case("ptx64", Triple::ptx64)
197 .Case("amdil", Triple::amdil)
198 .Default(Triple::UnknownArch);
199 }
200
201 // Returns architecture name that is understood by the target assembler.
getArchNameForAssembler()202 const char *Triple::getArchNameForAssembler() {
203 if (!isOSDarwin() && getVendor() != Triple::Apple)
204 return NULL;
205
206 return StringSwitch<const char*>(getArchName())
207 .Case("i386", "i386")
208 .Case("x86_64", "x86_64")
209 .Case("powerpc", "ppc")
210 .Case("powerpc64", "ppc64")
211 .Cases("mblaze", "microblaze", "mblaze")
212 .Case("arm", "arm")
213 .Cases("armv4t", "thumbv4t", "armv4t")
214 .Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5")
215 .Cases("armv6", "thumbv6", "armv6")
216 .Cases("armv7", "thumbv7", "armv7")
217 .Case("r600", "r600")
218 .Case("ptx32", "ptx32")
219 .Case("ptx64", "ptx64")
220 .Case("le32", "le32")
221 .Case("amdil", "amdil")
222 .Default(NULL);
223 }
224
parseArch(StringRef ArchName)225 static Triple::ArchType parseArch(StringRef ArchName) {
226 return StringSwitch<Triple::ArchType>(ArchName)
227 .Cases("i386", "i486", "i586", "i686", Triple::x86)
228 // FIXME: Do we need to support these?
229 .Cases("i786", "i886", "i986", Triple::x86)
230 .Cases("amd64", "x86_64", Triple::x86_64)
231 .Case("powerpc", Triple::ppc)
232 .Cases("powerpc64", "ppu", Triple::ppc64)
233 .Case("mblaze", Triple::mblaze)
234 .Cases("arm", "xscale", Triple::arm)
235 // FIXME: It would be good to replace these with explicit names for all the
236 // various suffixes supported.
237 .StartsWith("armv", Triple::arm)
238 .Case("thumb", Triple::thumb)
239 .StartsWith("thumbv", Triple::thumb)
240 .Cases("spu", "cellspu", Triple::cellspu)
241 .Case("msp430", Triple::msp430)
242 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
243 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
244 .Cases("mips64", "mips64eb", Triple::mips64)
245 .Case("mips64el", Triple::mips64el)
246 .Case("r600", Triple::r600)
247 .Case("hexagon", Triple::hexagon)
248 .Case("sparc", Triple::sparc)
249 .Case("sparcv9", Triple::sparcv9)
250 .Case("tce", Triple::tce)
251 .Case("xcore", Triple::xcore)
252 .Case("ptx32", Triple::ptx32)
253 .Case("ptx64", Triple::ptx64)
254 .Case("le32", Triple::le32)
255 .Case("amdil", Triple::amdil)
256 .Default(Triple::UnknownArch);
257 }
258
parseVendor(StringRef VendorName)259 static Triple::VendorType parseVendor(StringRef VendorName) {
260 return StringSwitch<Triple::VendorType>(VendorName)
261 .Case("apple", Triple::Apple)
262 .Case("pc", Triple::PC)
263 .Case("scei", Triple::SCEI)
264 .Case("bgp", Triple::BGP)
265 .Case("bgq", Triple::BGQ)
266 .Default(Triple::UnknownVendor);
267 }
268
parseOS(StringRef OSName)269 static Triple::OSType parseOS(StringRef OSName) {
270 return StringSwitch<Triple::OSType>(OSName)
271 .StartsWith("auroraux", Triple::AuroraUX)
272 .StartsWith("cygwin", Triple::Cygwin)
273 .StartsWith("darwin", Triple::Darwin)
274 .StartsWith("dragonfly", Triple::DragonFly)
275 .StartsWith("freebsd", Triple::FreeBSD)
276 .StartsWith("ios", Triple::IOS)
277 .StartsWith("kfreebsd", Triple::KFreeBSD)
278 .StartsWith("linux", Triple::Linux)
279 .StartsWith("lv2", Triple::Lv2)
280 .StartsWith("macosx", Triple::MacOSX)
281 .StartsWith("mingw32", Triple::MinGW32)
282 .StartsWith("netbsd", Triple::NetBSD)
283 .StartsWith("openbsd", Triple::OpenBSD)
284 .StartsWith("solaris", Triple::Solaris)
285 .StartsWith("win32", Triple::Win32)
286 .StartsWith("haiku", Triple::Haiku)
287 .StartsWith("minix", Triple::Minix)
288 .StartsWith("rtems", Triple::RTEMS)
289 .StartsWith("nacl", Triple::NativeClient)
290 .StartsWith("cnk", Triple::CNK)
291 .Default(Triple::UnknownOS);
292 }
293
parseEnvironment(StringRef EnvironmentName)294 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
295 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
296 .StartsWith("eabi", Triple::EABI)
297 .StartsWith("gnueabihf", Triple::GNUEABIHF)
298 .StartsWith("gnueabi", Triple::GNUEABI)
299 .StartsWith("gnu", Triple::GNU)
300 .StartsWith("macho", Triple::MachO)
301 .StartsWith("androideabi", Triple::ANDROIDEABI)
302 .Default(Triple::UnknownEnvironment);
303 }
304
305 /// \brief Construct a triple from the string representation provided.
306 ///
307 /// This stores the string representation and parses the various pieces into
308 /// enum members.
Triple(const Twine & Str)309 Triple::Triple(const Twine &Str)
310 : Data(Str.str()),
311 Arch(parseArch(getArchName())),
312 Vendor(parseVendor(getVendorName())),
313 OS(parseOS(getOSName())),
314 Environment(parseEnvironment(getEnvironmentName())) {
315 }
316
317 /// \brief Construct a triple from string representations of the architecture,
318 /// vendor, and OS.
319 ///
320 /// This joins each argument into a canonical string representation and parses
321 /// them into enum members. It leaves the environment unknown and omits it from
322 /// the string representation.
Triple(const Twine & ArchStr,const Twine & VendorStr,const Twine & OSStr)323 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
324 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
325 Arch(parseArch(ArchStr.str())),
326 Vendor(parseVendor(VendorStr.str())),
327 OS(parseOS(OSStr.str())),
328 Environment() {
329 }
330
331 /// \brief Construct a triple from string representations of the architecture,
332 /// vendor, OS, and environment.
333 ///
334 /// This joins each argument into a canonical string representation and parses
335 /// them into enum members.
Triple(const Twine & ArchStr,const Twine & VendorStr,const Twine & OSStr,const Twine & EnvironmentStr)336 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
337 const Twine &EnvironmentStr)
338 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
339 EnvironmentStr).str()),
340 Arch(parseArch(ArchStr.str())),
341 Vendor(parseVendor(VendorStr.str())),
342 OS(parseOS(OSStr.str())),
343 Environment(parseEnvironment(EnvironmentStr.str())) {
344 }
345
normalize(StringRef Str)346 std::string Triple::normalize(StringRef Str) {
347 // Parse into components.
348 SmallVector<StringRef, 4> Components;
349 Str.split(Components, "-");
350
351 // If the first component corresponds to a known architecture, preferentially
352 // use it for the architecture. If the second component corresponds to a
353 // known vendor, preferentially use it for the vendor, etc. This avoids silly
354 // component movement when a component parses as (eg) both a valid arch and a
355 // valid os.
356 ArchType Arch = UnknownArch;
357 if (Components.size() > 0)
358 Arch = parseArch(Components[0]);
359 VendorType Vendor = UnknownVendor;
360 if (Components.size() > 1)
361 Vendor = parseVendor(Components[1]);
362 OSType OS = UnknownOS;
363 if (Components.size() > 2)
364 OS = parseOS(Components[2]);
365 EnvironmentType Environment = UnknownEnvironment;
366 if (Components.size() > 3)
367 Environment = parseEnvironment(Components[3]);
368
369 // Note which components are already in their final position. These will not
370 // be moved.
371 bool Found[4];
372 Found[0] = Arch != UnknownArch;
373 Found[1] = Vendor != UnknownVendor;
374 Found[2] = OS != UnknownOS;
375 Found[3] = Environment != UnknownEnvironment;
376
377 // If they are not there already, permute the components into their canonical
378 // positions by seeing if they parse as a valid architecture, and if so moving
379 // the component to the architecture position etc.
380 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
381 if (Found[Pos])
382 continue; // Already in the canonical position.
383
384 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
385 // Do not reparse any components that already matched.
386 if (Idx < array_lengthof(Found) && Found[Idx])
387 continue;
388
389 // Does this component parse as valid for the target position?
390 bool Valid = false;
391 StringRef Comp = Components[Idx];
392 switch (Pos) {
393 default: llvm_unreachable("unexpected component type!");
394 case 0:
395 Arch = parseArch(Comp);
396 Valid = Arch != UnknownArch;
397 break;
398 case 1:
399 Vendor = parseVendor(Comp);
400 Valid = Vendor != UnknownVendor;
401 break;
402 case 2:
403 OS = parseOS(Comp);
404 Valid = OS != UnknownOS;
405 break;
406 case 3:
407 Environment = parseEnvironment(Comp);
408 Valid = Environment != UnknownEnvironment;
409 break;
410 }
411 if (!Valid)
412 continue; // Nope, try the next component.
413
414 // Move the component to the target position, pushing any non-fixed
415 // components that are in the way to the right. This tends to give
416 // good results in the common cases of a forgotten vendor component
417 // or a wrongly positioned environment.
418 if (Pos < Idx) {
419 // Insert left, pushing the existing components to the right. For
420 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
421 StringRef CurrentComponent(""); // The empty component.
422 // Replace the component we are moving with an empty component.
423 std::swap(CurrentComponent, Components[Idx]);
424 // Insert the component being moved at Pos, displacing any existing
425 // components to the right.
426 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
427 // Skip over any fixed components.
428 while (i < array_lengthof(Found) && Found[i])
429 ++i;
430 // Place the component at the new position, getting the component
431 // that was at this position - it will be moved right.
432 std::swap(CurrentComponent, Components[i]);
433 }
434 } else if (Pos > Idx) {
435 // Push right by inserting empty components until the component at Idx
436 // reaches the target position Pos. For example, pc-a -> -pc-a when
437 // moving pc to the second position.
438 do {
439 // Insert one empty component at Idx.
440 StringRef CurrentComponent(""); // The empty component.
441 for (unsigned i = Idx; i < Components.size();) {
442 // Place the component at the new position, getting the component
443 // that was at this position - it will be moved right.
444 std::swap(CurrentComponent, Components[i]);
445 // If it was placed on top of an empty component then we are done.
446 if (CurrentComponent.empty())
447 break;
448 // Advance to the next component, skipping any fixed components.
449 while (++i < array_lengthof(Found) && Found[i])
450 ;
451 }
452 // The last component was pushed off the end - append it.
453 if (!CurrentComponent.empty())
454 Components.push_back(CurrentComponent);
455
456 // Advance Idx to the component's new position.
457 while (++Idx < array_lengthof(Found) && Found[Idx])
458 ;
459 } while (Idx < Pos); // Add more until the final position is reached.
460 }
461 assert(Pos < Components.size() && Components[Pos] == Comp &&
462 "Component moved wrong!");
463 Found[Pos] = true;
464 break;
465 }
466 }
467
468 // Special case logic goes here. At this point Arch, Vendor and OS have the
469 // correct values for the computed components.
470
471 // Stick the corrected components back together to form the normalized string.
472 std::string Normalized;
473 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
474 if (i) Normalized += '-';
475 Normalized += Components[i];
476 }
477 return Normalized;
478 }
479
getArchName() const480 StringRef Triple::getArchName() const {
481 return StringRef(Data).split('-').first; // Isolate first component
482 }
483
getVendorName() const484 StringRef Triple::getVendorName() const {
485 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
486 return Tmp.split('-').first; // Isolate second component
487 }
488
getOSName() const489 StringRef Triple::getOSName() const {
490 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
491 Tmp = Tmp.split('-').second; // Strip second component
492 return Tmp.split('-').first; // Isolate third component
493 }
494
getEnvironmentName() const495 StringRef Triple::getEnvironmentName() const {
496 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
497 Tmp = Tmp.split('-').second; // Strip second component
498 return Tmp.split('-').second; // Strip third component
499 }
500
getOSAndEnvironmentName() const501 StringRef Triple::getOSAndEnvironmentName() const {
502 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
503 return Tmp.split('-').second; // Strip second component
504 }
505
EatNumber(StringRef & Str)506 static unsigned EatNumber(StringRef &Str) {
507 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
508 unsigned Result = 0;
509
510 do {
511 // Consume the leading digit.
512 Result = Result*10 + (Str[0] - '0');
513
514 // Eat the digit.
515 Str = Str.substr(1);
516 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
517
518 return Result;
519 }
520
getOSVersion(unsigned & Major,unsigned & Minor,unsigned & Micro) const521 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
522 unsigned &Micro) const {
523 StringRef OSName = getOSName();
524
525 // Assume that the OS portion of the triple starts with the canonical name.
526 StringRef OSTypeName = getOSTypeName(getOS());
527 if (OSName.startswith(OSTypeName))
528 OSName = OSName.substr(OSTypeName.size());
529
530 // Any unset version defaults to 0.
531 Major = Minor = Micro = 0;
532
533 // Parse up to three components.
534 unsigned *Components[3] = { &Major, &Minor, &Micro };
535 for (unsigned i = 0; i != 3; ++i) {
536 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
537 break;
538
539 // Consume the leading number.
540 *Components[i] = EatNumber(OSName);
541
542 // Consume the separator, if present.
543 if (OSName.startswith("."))
544 OSName = OSName.substr(1);
545 }
546 }
547
getMacOSXVersion(unsigned & Major,unsigned & Minor,unsigned & Micro) const548 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
549 unsigned &Micro) const {
550 getOSVersion(Major, Minor, Micro);
551
552 switch (getOS()) {
553 default: llvm_unreachable("unexpected OS for Darwin triple");
554 case Darwin:
555 // Default to darwin8, i.e., MacOSX 10.4.
556 if (Major == 0)
557 Major = 8;
558 // Darwin version numbers are skewed from OS X versions.
559 if (Major < 4)
560 return false;
561 Micro = 0;
562 Minor = Major - 4;
563 Major = 10;
564 break;
565 case MacOSX:
566 // Default to 10.4.
567 if (Major == 0) {
568 Major = 10;
569 Minor = 4;
570 }
571 if (Major != 10)
572 return false;
573 break;
574 case IOS:
575 // Ignore the version from the triple. This is only handled because the
576 // the clang driver combines OS X and IOS support into a common Darwin
577 // toolchain that wants to know the OS X version number even when targeting
578 // IOS.
579 Major = 10;
580 Minor = 4;
581 Micro = 0;
582 break;
583 }
584 return true;
585 }
586
setTriple(const Twine & Str)587 void Triple::setTriple(const Twine &Str) {
588 *this = Triple(Str);
589 }
590
setArch(ArchType Kind)591 void Triple::setArch(ArchType Kind) {
592 setArchName(getArchTypeName(Kind));
593 }
594
setVendor(VendorType Kind)595 void Triple::setVendor(VendorType Kind) {
596 setVendorName(getVendorTypeName(Kind));
597 }
598
setOS(OSType Kind)599 void Triple::setOS(OSType Kind) {
600 setOSName(getOSTypeName(Kind));
601 }
602
setEnvironment(EnvironmentType Kind)603 void Triple::setEnvironment(EnvironmentType Kind) {
604 setEnvironmentName(getEnvironmentTypeName(Kind));
605 }
606
setArchName(StringRef Str)607 void Triple::setArchName(StringRef Str) {
608 // Work around a miscompilation bug for Twines in gcc 4.0.3.
609 SmallString<64> Triple;
610 Triple += Str;
611 Triple += "-";
612 Triple += getVendorName();
613 Triple += "-";
614 Triple += getOSAndEnvironmentName();
615 setTriple(Triple.str());
616 }
617
setVendorName(StringRef Str)618 void Triple::setVendorName(StringRef Str) {
619 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
620 }
621
setOSName(StringRef Str)622 void Triple::setOSName(StringRef Str) {
623 if (hasEnvironment())
624 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
625 "-" + getEnvironmentName());
626 else
627 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
628 }
629
setEnvironmentName(StringRef Str)630 void Triple::setEnvironmentName(StringRef Str) {
631 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
632 "-" + Str);
633 }
634
setOSAndEnvironmentName(StringRef Str)635 void Triple::setOSAndEnvironmentName(StringRef Str) {
636 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
637 }
638
getArchPointerBitWidth(llvm::Triple::ArchType Arch)639 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
640 switch (Arch) {
641 case llvm::Triple::UnknownArch:
642 return 0;
643
644 case llvm::Triple::msp430:
645 return 16;
646
647 case llvm::Triple::amdil:
648 case llvm::Triple::arm:
649 case llvm::Triple::cellspu:
650 case llvm::Triple::hexagon:
651 case llvm::Triple::le32:
652 case llvm::Triple::mblaze:
653 case llvm::Triple::mips:
654 case llvm::Triple::mipsel:
655 case llvm::Triple::ppc:
656 case llvm::Triple::ptx32:
657 case llvm::Triple::r600:
658 case llvm::Triple::sparc:
659 case llvm::Triple::tce:
660 case llvm::Triple::thumb:
661 case llvm::Triple::x86:
662 case llvm::Triple::xcore:
663 return 32;
664
665 case llvm::Triple::mips64:
666 case llvm::Triple::mips64el:
667 case llvm::Triple::ppc64:
668 case llvm::Triple::ptx64:
669 case llvm::Triple::sparcv9:
670 case llvm::Triple::x86_64:
671 return 64;
672 }
673 llvm_unreachable("Invalid architecture value");
674 }
675
isArch64Bit() const676 bool Triple::isArch64Bit() const {
677 return getArchPointerBitWidth(getArch()) == 64;
678 }
679
isArch32Bit() const680 bool Triple::isArch32Bit() const {
681 return getArchPointerBitWidth(getArch()) == 32;
682 }
683
isArch16Bit() const684 bool Triple::isArch16Bit() const {
685 return getArchPointerBitWidth(getArch()) == 16;
686 }
687
get32BitArchVariant() const688 Triple Triple::get32BitArchVariant() const {
689 Triple T(*this);
690 switch (getArch()) {
691 case Triple::UnknownArch:
692 case Triple::msp430:
693 T.setArch(UnknownArch);
694 break;
695
696 case Triple::amdil:
697 case Triple::arm:
698 case Triple::cellspu:
699 case Triple::hexagon:
700 case Triple::le32:
701 case Triple::mblaze:
702 case Triple::mips:
703 case Triple::mipsel:
704 case Triple::ppc:
705 case Triple::ptx32:
706 case Triple::r600:
707 case Triple::sparc:
708 case Triple::tce:
709 case Triple::thumb:
710 case Triple::x86:
711 case Triple::xcore:
712 // Already 32-bit.
713 break;
714
715 case Triple::mips64: T.setArch(Triple::mips); break;
716 case Triple::mips64el: T.setArch(Triple::mipsel); break;
717 case Triple::ppc64: T.setArch(Triple::ppc); break;
718 case Triple::ptx64: T.setArch(Triple::ptx32); break;
719 case Triple::sparcv9: T.setArch(Triple::sparc); break;
720 case Triple::x86_64: T.setArch(Triple::x86); break;
721 }
722 return T;
723 }
724
get64BitArchVariant() const725 Triple Triple::get64BitArchVariant() const {
726 Triple T(*this);
727 switch (getArch()) {
728 case Triple::UnknownArch:
729 case Triple::amdil:
730 case Triple::arm:
731 case Triple::cellspu:
732 case Triple::hexagon:
733 case Triple::le32:
734 case Triple::mblaze:
735 case Triple::msp430:
736 case Triple::r600:
737 case Triple::tce:
738 case Triple::thumb:
739 case Triple::xcore:
740 T.setArch(UnknownArch);
741 break;
742
743 case Triple::mips64:
744 case Triple::mips64el:
745 case Triple::ppc64:
746 case Triple::ptx64:
747 case Triple::sparcv9:
748 case Triple::x86_64:
749 // Already 64-bit.
750 break;
751
752 case Triple::mips: T.setArch(Triple::mips64); break;
753 case Triple::mipsel: T.setArch(Triple::mips64el); break;
754 case Triple::ppc: T.setArch(Triple::ppc64); break;
755 case Triple::ptx32: T.setArch(Triple::ptx64); break;
756 case Triple::sparc: T.setArch(Triple::sparcv9); break;
757 case Triple::x86: T.setArch(Triple::x86_64); break;
758 }
759 return T;
760 }
761