Clang Project

clang_source_code/lib/Basic/Targets/OSTargets.h
1//===--- OSTargets.h - Declare OS target feature support --------*- 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 declares OS specific TargetInfo types.
10//===----------------------------------------------------------------------===//
11
12#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
13#define LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
14
15#include "Targets.h"
16#include "llvm/MC/MCSectionMachO.h"
17
18namespace clang {
19namespace targets {
20
21template <typename TgtInfo>
22class LLVM_LIBRARY_VISIBILITY OSTargetInfo : public TgtInfo {
23protected:
24  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
25                            MacroBuilder &Builder) const = 0;
26
27public:
28  OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
29      : TgtInfo(Triple, Opts) {}
30
31  void getTargetDefines(const LangOptions &Opts,
32                        MacroBuilder &Builder) const override {
33    TgtInfo::getTargetDefines(Opts, Builder);
34    getOSDefines(Opts, TgtInfo::getTriple(), Builder);
35  }
36};
37
38// CloudABI Target
39template <typename Target>
40class LLVM_LIBRARY_VISIBILITY CloudABITargetInfo : public OSTargetInfo<Target> {
41protected:
42  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
43                    MacroBuilder &Builder) const override {
44    Builder.defineMacro("__CloudABI__");
45    Builder.defineMacro("__ELF__");
46
47    // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
48    Builder.defineMacro("__STDC_ISO_10646__", "201206L");
49    Builder.defineMacro("__STDC_UTF_16__");
50    Builder.defineMacro("__STDC_UTF_32__");
51  }
52
53public:
54  CloudABITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
55      : OSTargetInfo<Target>(Triple, Opts) {}
56};
57
58// Ananas target
59template <typename Target>
60class LLVM_LIBRARY_VISIBILITY AnanasTargetInfo : public OSTargetInfo<Target> {
61protected:
62  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
63                    MacroBuilder &Builder) const override {
64    // Ananas defines
65    Builder.defineMacro("__Ananas__");
66    Builder.defineMacro("__ELF__");
67  }
68
69public:
70  AnanasTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
71      : OSTargetInfo<Target>(Triple, Opts) {}
72};
73
74void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
75                      const llvm::Triple &Triple, StringRef &PlatformName,
76                      VersionTuple &PlatformMinVersion);
77
78template <typename Target>
79class LLVM_LIBRARY_VISIBILITY DarwinTargetInfo : public OSTargetInfo<Target> {
80protected:
81  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
82                    MacroBuilder &Builder) const override {
83    getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
84                     this->PlatformMinVersion);
85  }
86
87public:
88  DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
89      : OSTargetInfo<Target>(Triple, Opts) {
90    // By default, no TLS, and we whitelist permitted architecture/OS
91    // combinations.
92    this->TLSSupported = false;
93
94    if (Triple.isMacOSX())
95      this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7);
96    else if (Triple.isiOS()) {
97      // 64-bit iOS supported it from 8 onwards, 32-bit device from 9 onwards,
98      // 32-bit simulator from 10 onwards.
99      if (Triple.isArch64Bit())
100        this->TLSSupported = !Triple.isOSVersionLT(8);
101      else if (Triple.isArch32Bit()) {
102        if (!Triple.isSimulatorEnvironment())
103          this->TLSSupported = !Triple.isOSVersionLT(9);
104        else
105          this->TLSSupported = !Triple.isOSVersionLT(10);
106      }
107    } else if (Triple.isWatchOS()) {
108      if (!Triple.isSimulatorEnvironment())
109        this->TLSSupported = !Triple.isOSVersionLT(2);
110      else
111        this->TLSSupported = !Triple.isOSVersionLT(3);
112    }
113
114    this->MCountName = "\01mcount";
115  }
116
117  std::string isValidSectionSpecifier(StringRef SR) const override {
118    // Let MCSectionMachO validate this.
119    StringRef Segment, Section;
120    unsigned TAA, StubSize;
121    bool HasTAA;
122    return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
123                                                       TAA, HasTAA, StubSize);
124  }
125
126  const char *getStaticInitSectionSpecifier() const override {
127    // FIXME: We should return 0 when building kexts.
128    return "__TEXT,__StaticInit,regular,pure_instructions";
129  }
130
131  /// Darwin does not support protected visibility.  Darwin's "default"
132  /// is very similar to ELF's "protected";  Darwin requires a "weak"
133  /// attribute on declarations that can be dynamically replaced.
134  bool hasProtectedVisibility() const override { return false; }
135
136  TargetInfo::IntType getLeastIntTypeByWidth(unsigned BitWidth,
137                                             bool IsSigned) const final {
138    // Darwin uses `long long` for `int_least64_t` and `int_fast64_t`.
139    return BitWidth == 64
140               ? (IsSigned ? TargetInfo::SignedLongLong
141                           : TargetInfo::UnsignedLongLong)
142               : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
143  }
144};
145
146// DragonFlyBSD Target
147template <typename Target>
148class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo
149    : public OSTargetInfo<Target> {
150protected:
151  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
152                    MacroBuilder &Builder) const override {
153    // DragonFly defines; list based off of gcc output
154    Builder.defineMacro("__DragonFly__");
155    Builder.defineMacro("__DragonFly_cc_version", "100001");
156    Builder.defineMacro("__ELF__");
157    Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
158    Builder.defineMacro("__tune_i386__");
159    DefineStd(Builder, "unix", Opts);
160  }
161
162public:
163  DragonFlyBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
164      : OSTargetInfo<Target>(Triple, Opts) {
165    switch (Triple.getArch()) {
166    default:
167    case llvm::Triple::x86:
168    case llvm::Triple::x86_64:
169      this->MCountName = ".mcount";
170      break;
171    }
172  }
173};
174
175#ifndef FREEBSD_CC_VERSION
176#define FREEBSD_CC_VERSION 0U
177#endif
178
179// FreeBSD Target
180template <typename Target>
181class LLVM_LIBRARY_VISIBILITY FreeBSDTargetInfo : public OSTargetInfo<Target> {
182protected:
183  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
184                    MacroBuilder &Builder) const override {
185    // FreeBSD defines; list based off of gcc output
186
187    unsigned Release = Triple.getOSMajorVersion();
188    if (Release == 0U)
189      Release = 8U;
190    unsigned CCVersion = FREEBSD_CC_VERSION;
191    if (CCVersion == 0U)
192      CCVersion = Release * 100000U + 1U;
193
194    Builder.defineMacro("__FreeBSD__", Twine(Release));
195    Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion));
196    Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
197    DefineStd(Builder, "unix", Opts);
198    Builder.defineMacro("__ELF__");
199
200    // On FreeBSD, wchar_t contains the number of the code point as
201    // used by the character set of the locale. These character sets are
202    // not necessarily a superset of ASCII.
203    //
204    // FIXME: This is wrong; the macro refers to the numerical values
205    // of wchar_t *literals*, which are not locale-dependent. However,
206    // FreeBSD systems apparently depend on us getting this wrong, and
207    // setting this to 1 is conforming even if all the basic source
208    // character literals have the same encoding as char and wchar_t.
209    Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
210  }
211
212public:
213  FreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
214      : OSTargetInfo<Target>(Triple, Opts) {
215    switch (Triple.getArch()) {
216    default:
217    case llvm::Triple::x86:
218    case llvm::Triple::x86_64:
219      this->MCountName = ".mcount";
220      break;
221    case llvm::Triple::mips:
222    case llvm::Triple::mipsel:
223    case llvm::Triple::ppc:
224    case llvm::Triple::ppc64:
225    case llvm::Triple::ppc64le:
226      this->MCountName = "_mcount";
227      break;
228    case llvm::Triple::arm:
229      this->MCountName = "__mcount";
230      break;
231    }
232  }
233};
234
235// GNU/kFreeBSD Target
236template <typename Target>
237class LLVM_LIBRARY_VISIBILITY KFreeBSDTargetInfo : public OSTargetInfo<Target> {
238protected:
239  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
240                    MacroBuilder &Builder) const override {
241    // GNU/kFreeBSD defines; list based off of gcc output
242
243    DefineStd(Builder, "unix", Opts);
244    Builder.defineMacro("__FreeBSD_kernel__");
245    Builder.defineMacro("__GLIBC__");
246    Builder.defineMacro("__ELF__");
247    if (Opts.POSIXThreads)
248      Builder.defineMacro("_REENTRANT");
249    if (Opts.CPlusPlus)
250      Builder.defineMacro("_GNU_SOURCE");
251  }
252
253public:
254  KFreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
255      : OSTargetInfo<Target>(Triple, Opts) {}
256};
257
258// Haiku Target
259template <typename Target>
260class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> {
261protected:
262  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
263                    MacroBuilder &Builder) const override {
264    // Haiku defines; list based off of gcc output
265    Builder.defineMacro("__HAIKU__");
266    Builder.defineMacro("__ELF__");
267    DefineStd(Builder, "unix", Opts);
268    if (this->HasFloat128) 
269      Builder.defineMacro("__FLOAT128__");
270  }
271
272public:
273  HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
274      : OSTargetInfo<Target>(Triple, Opts) {
275    this->SizeType = TargetInfo::UnsignedLong;
276    this->IntPtrType = TargetInfo::SignedLong;
277    this->PtrDiffType = TargetInfo::SignedLong;
278    this->ProcessIDType = TargetInfo::SignedLong;
279    this->TLSSupported = false;
280    switch (Triple.getArch()) {
281    default:
282      break;
283    case llvm::Triple::x86:
284    case llvm::Triple::x86_64:
285      this->HasFloat128 = true;
286      break;
287    }
288  }
289};
290
291// Hurd target
292template <typename Target>
293class LLVM_LIBRARY_VISIBILITY HurdTargetInfo : public OSTargetInfo<Target> {
294protected:
295  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
296                    MacroBuilder &Builder) const override {
297    // Hurd defines; list based off of gcc output.
298    DefineStd(Builder, "unix", Opts);
299    Builder.defineMacro("__GNU__");
300    Builder.defineMacro("__gnu_hurd__");
301    Builder.defineMacro("__MACH__");
302    Builder.defineMacro("__GLIBC__");
303    Builder.defineMacro("__ELF__");
304    if (Opts.POSIXThreads)
305      Builder.defineMacro("_REENTRANT");
306    if (Opts.CPlusPlus)
307      Builder.defineMacro("_GNU_SOURCE");
308  }
309public:
310  HurdTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
311      : OSTargetInfo<Target>(Triple, Opts) {}
312};
313
314// Minix Target
315template <typename Target>
316class LLVM_LIBRARY_VISIBILITY MinixTargetInfo : public OSTargetInfo<Target> {
317protected:
318  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
319                    MacroBuilder &Builder) const override {
320    // Minix defines
321
322    Builder.defineMacro("__minix", "3");
323    Builder.defineMacro("_EM_WSIZE", "4");
324    Builder.defineMacro("_EM_PSIZE", "4");
325    Builder.defineMacro("_EM_SSIZE", "2");
326    Builder.defineMacro("_EM_LSIZE", "4");
327    Builder.defineMacro("_EM_FSIZE", "4");
328    Builder.defineMacro("_EM_DSIZE", "8");
329    Builder.defineMacro("__ELF__");
330    DefineStd(Builder, "unix", Opts);
331  }
332
333public:
334  MinixTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
335      : OSTargetInfo<Target>(Triple, Opts) {}
336};
337
338// Linux target
339template <typename Target>
340class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {
341protected:
342  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
343                    MacroBuilder &Builder) const override {
344    // Linux defines; list based off of gcc output
345    DefineStd(Builder, "unix", Opts);
346    DefineStd(Builder, "linux", Opts);
347    Builder.defineMacro("__ELF__");
348    if (Triple.isAndroid()) {
349      Builder.defineMacro("__ANDROID__", "1");
350      unsigned Maj, Min, Rev;
351      Triple.getEnvironmentVersion(Maj, Min, Rev);
352      this->PlatformName = "android";
353      this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
354      if (Maj)
355        Builder.defineMacro("__ANDROID_API__", Twine(Maj));
356    } else {
357        Builder.defineMacro("__gnu_linux__");
358    }
359    if (Opts.POSIXThreads)
360      Builder.defineMacro("_REENTRANT");
361    if (Opts.CPlusPlus)
362      Builder.defineMacro("_GNU_SOURCE");
363    if (this->HasFloat128)
364      Builder.defineMacro("__FLOAT128__");
365  }
366
367public:
368  LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
369      : OSTargetInfo<Target>(Triple, Opts) {
370    this->WIntType = TargetInfo::UnsignedInt;
371
372    switch (Triple.getArch()) {
373    default:
374      break;
375    case llvm::Triple::mips:
376    case llvm::Triple::mipsel:
377    case llvm::Triple::mips64:
378    case llvm::Triple::mips64el:
379    case llvm::Triple::ppc:
380    case llvm::Triple::ppc64:
381    case llvm::Triple::ppc64le:
382      this->MCountName = "_mcount";
383      break;
384    case llvm::Triple::x86:
385    case llvm::Triple::x86_64:
386      this->HasFloat128 = true;
387      break;
388    }
389  }
390
391  const char *getStaticInitSectionSpecifier() const override {
392    return ".text.startup";
393  }
394};
395
396// NetBSD Target
397template <typename Target>
398class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> {
399protected:
400  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
401                    MacroBuilder &Builder) const override {
402    // NetBSD defines; list based off of gcc output
403    Builder.defineMacro("__NetBSD__");
404    Builder.defineMacro("__unix__");
405    Builder.defineMacro("__ELF__");
406    if (Opts.POSIXThreads)
407      Builder.defineMacro("_REENTRANT");
408  }
409
410public:
411  NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
412      : OSTargetInfo<Target>(Triple, Opts) {
413    this->MCountName = "__mcount";
414  }
415};
416
417// OpenBSD Target
418template <typename Target>
419class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> {
420protected:
421  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
422                    MacroBuilder &Builder) const override {
423    // OpenBSD defines; list based off of gcc output
424
425    Builder.defineMacro("__OpenBSD__");
426    DefineStd(Builder, "unix", Opts);
427    Builder.defineMacro("__ELF__");
428    if (Opts.POSIXThreads)
429      Builder.defineMacro("_REENTRANT");
430    if (this->HasFloat128)
431      Builder.defineMacro("__FLOAT128__");
432  }
433
434public:
435  OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
436      : OSTargetInfo<Target>(Triple, Opts) {
437    switch (Triple.getArch()) {
438    case llvm::Triple::x86:
439    case llvm::Triple::x86_64:
440      this->HasFloat128 = true;
441      LLVM_FALLTHROUGH;
442    default:
443      this->MCountName = "__mcount";
444      break;
445    case llvm::Triple::mips64:
446    case llvm::Triple::mips64el:
447    case llvm::Triple::ppc:
448    case llvm::Triple::sparcv9:
449      this->MCountName = "_mcount";
450      break;
451    }
452  }
453};
454
455// PSP Target
456template <typename Target>
457class LLVM_LIBRARY_VISIBILITY PSPTargetInfo : public OSTargetInfo<Target> {
458protected:
459  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
460                    MacroBuilder &Builder) const override {
461    // PSP defines; list based on the output of the pspdev gcc toolchain.
462    Builder.defineMacro("PSP");
463    Builder.defineMacro("_PSP");
464    Builder.defineMacro("__psp__");
465    Builder.defineMacro("__ELF__");
466  }
467
468public:
469  PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {}
470};
471
472// PS3 PPU Target
473template <typename Target>
474class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> {
475protected:
476  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
477                    MacroBuilder &Builder) const override {
478    // PS3 PPU defines.
479    Builder.defineMacro("__PPC__");
480    Builder.defineMacro("__PPU__");
481    Builder.defineMacro("__CELLOS_LV2__");
482    Builder.defineMacro("__ELF__");
483    Builder.defineMacro("__LP32__");
484    Builder.defineMacro("_ARCH_PPC64");
485    Builder.defineMacro("__powerpc64__");
486  }
487
488public:
489  PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
490      : OSTargetInfo<Target>(Triple, Opts) {
491    this->LongWidth = this->LongAlign = 32;
492    this->PointerWidth = this->PointerAlign = 32;
493    this->IntMaxType = TargetInfo::SignedLongLong;
494    this->Int64Type = TargetInfo::SignedLongLong;
495    this->SizeType = TargetInfo::UnsignedInt;
496    this->resetDataLayout("E-m:e-p:32:32-i64:64-n32:64");
497  }
498};
499
500template <typename Target>
501class LLVM_LIBRARY_VISIBILITY PS4OSTargetInfo : public OSTargetInfo<Target> {
502protected:
503  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
504                    MacroBuilder &Builder) const override {
505    Builder.defineMacro("__FreeBSD__", "9");
506    Builder.defineMacro("__FreeBSD_cc_version", "900001");
507    Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
508    DefineStd(Builder, "unix", Opts);
509    Builder.defineMacro("__ELF__");
510    Builder.defineMacro("__ORBIS__");
511  }
512
513public:
514  PS4OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
515      : OSTargetInfo<Target>(Triple, Opts) {
516    this->WCharType = TargetInfo::UnsignedShort;
517
518    // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
519    this->MaxTLSAlign = 256;
520
521    // On PS4, do not honor explicit bit field alignment,
522    // as in "__attribute__((aligned(2))) int b : 1;".
523    this->UseExplicitBitFieldAlignment = false;
524
525    switch (Triple.getArch()) {
526    default:
527    case llvm::Triple::x86_64:
528      this->MCountName = ".mcount";
529      this->NewAlign = 256;
530      break;
531    }
532  }
533};
534
535// RTEMS Target
536template <typename Target>
537class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> {
538protected:
539  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
540                    MacroBuilder &Builder) const override {
541    // RTEMS defines; list based off of gcc output
542
543    Builder.defineMacro("__rtems__");
544    Builder.defineMacro("__ELF__");
545    if (Opts.CPlusPlus)
546      Builder.defineMacro("_GNU_SOURCE");
547  }
548
549public:
550  RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
551      : OSTargetInfo<Target>(Triple, Opts) {
552    switch (Triple.getArch()) {
553    default:
554    case llvm::Triple::x86:
555      // this->MCountName = ".mcount";
556      break;
557    case llvm::Triple::mips:
558    case llvm::Triple::mipsel:
559    case llvm::Triple::ppc:
560    case llvm::Triple::ppc64:
561    case llvm::Triple::ppc64le:
562      // this->MCountName = "_mcount";
563      break;
564    case llvm::Triple::arm:
565      // this->MCountName = "__mcount";
566      break;
567    }
568  }
569};
570
571// Solaris target
572template <typename Target>
573class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> {
574protected:
575  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
576                    MacroBuilder &Builder) const override {
577    DefineStd(Builder, "sun", Opts);
578    DefineStd(Builder, "unix", Opts);
579    Builder.defineMacro("__ELF__");
580    Builder.defineMacro("__svr4__");
581    Builder.defineMacro("__SVR4");
582    // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
583    // newer, but to 500 for everything else.  feature_test.h has a check to
584    // ensure that you are not using C99 with an old version of X/Open or C89
585    // with a new version.
586    if (Opts.C99)
587      Builder.defineMacro("_XOPEN_SOURCE", "600");
588    else
589      Builder.defineMacro("_XOPEN_SOURCE", "500");
590    if (Opts.CPlusPlus)
591      Builder.defineMacro("__C99FEATURES__");
592    Builder.defineMacro("_LARGEFILE_SOURCE");
593    Builder.defineMacro("_LARGEFILE64_SOURCE");
594    Builder.defineMacro("__EXTENSIONS__");
595    if (Opts.POSIXThreads)
596      Builder.defineMacro("_REENTRANT");
597    if (this->HasFloat128)
598      Builder.defineMacro("__FLOAT128__");
599  }
600
601public:
602  SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
603      : OSTargetInfo<Target>(Triple, Opts) {
604    // FIXME: WIntType should be SignedLong
605    switch (Triple.getArch()) {
606    default:
607      break;
608    case llvm::Triple::x86:
609    case llvm::Triple::x86_64:
610      this->HasFloat128 = true;
611      break;
612    }
613  }
614};
615
616// AIX Target
617template <typename Target>
618class AIXTargetInfo : public OSTargetInfo<Target> {
619protected:
620  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
621                    MacroBuilder &Builder) const override {
622    DefineStd(Builder, "unix", Opts);
623    Builder.defineMacro("_IBMR2");
624    Builder.defineMacro("_POWER");
625
626    // FIXME: Define AIX OS-Version Macros.
627    Builder.defineMacro("_AIX");
628
629    // FIXME: Do not define _LONG_LONG when -fno-long-long is specified.
630    Builder.defineMacro("_LONG_LONG");
631
632    if (Opts.POSIXThreads) {
633      Builder.defineMacro("_THREAD_SAFE");
634    }
635
636    if (this->PointerWidth == 64) {
637      Builder.defineMacro("__64BIT__");
638    }
639
640    // Define _WCHAR_T when it is a fundamental type
641    // (i.e., for C++ without -fno-wchar).
642    if (Opts.CPlusPlus && Opts.WChar) {
643      Builder.defineMacro("_WCHAR_T");
644    }
645  }
646
647public:
648  AIXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
649      : OSTargetInfo<Target>(Triple, Opts) {
650    if (this->PointerWidth == 64) {
651      this->WCharType = this->UnsignedInt;
652    } else {
653      this->WCharType = this->UnsignedShort;
654    }
655    this->UseZeroLengthBitfieldAlignment = true;
656  }
657
658  // AIX sets FLT_EVAL_METHOD to be 1.
659  unsigned getFloatEvalMethod() const override { return 1; }
660  bool hasInt128Type() const override { return false; }
661};
662
663// Windows target
664template <typename Target>
665class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> {
666protected:
667  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
668                    MacroBuilder &Builder) const override {
669    Builder.defineMacro("_WIN32");
670    if (Triple.isArch64Bit())
671      Builder.defineMacro("_WIN64");
672    if (Triple.isWindowsGNUEnvironment())
673      addMinGWDefines(Triple, Opts, Builder);
674
675  }
676  void getVisualStudioDefines(const LangOptions &Opts,
677                              MacroBuilder &Builder) const {
678    if (Opts.CPlusPlus) {
679      if (Opts.RTTIData)
680        Builder.defineMacro("_CPPRTTI");
681
682      if (Opts.CXXExceptions)
683        Builder.defineMacro("_CPPUNWIND");
684    }
685
686    if (Opts.Bool)
687      Builder.defineMacro("__BOOL_DEFINED");
688
689    if (!Opts.CharIsSigned)
690      Builder.defineMacro("_CHAR_UNSIGNED");
691
692    // FIXME: POSIXThreads isn't exactly the option this should be defined for,
693    //        but it works for now.
694    if (Opts.POSIXThreads)
695      Builder.defineMacro("_MT");
696
697    if (Opts.MSCompatibilityVersion) {
698      Builder.defineMacro("_MSC_VER",
699                          Twine(Opts.MSCompatibilityVersion / 100000));
700      Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
701      // FIXME We cannot encode the revision information into 32-bits
702      Builder.defineMacro("_MSC_BUILD", Twine(1));
703
704      if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
705        Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
706
707      if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) {
708        if (Opts.CPlusPlus2a)
709          Builder.defineMacro("_MSVC_LANG", "201704L");
710        else if (Opts.CPlusPlus17)
711          Builder.defineMacro("_MSVC_LANG", "201703L");
712        else if (Opts.CPlusPlus14)
713          Builder.defineMacro("_MSVC_LANG", "201402L");
714      }
715    }
716
717    if (Opts.MicrosoftExt) {
718      Builder.defineMacro("_MSC_EXTENSIONS");
719
720      if (Opts.CPlusPlus11) {
721        Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
722        Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
723        Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
724      }
725    }
726
727    Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
728  }
729
730public:
731  WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
732      : OSTargetInfo<Target>(Triple, Opts) {
733    this->WCharType = TargetInfo::UnsignedShort;
734    this->WIntType = TargetInfo::UnsignedShort;
735  }
736};
737
738template <typename Target>
739class LLVM_LIBRARY_VISIBILITY NaClTargetInfo : public OSTargetInfo<Target> {
740protected:
741  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
742                    MacroBuilder &Builder) const override {
743    if (Opts.POSIXThreads)
744      Builder.defineMacro("_REENTRANT");
745    if (Opts.CPlusPlus)
746      Builder.defineMacro("_GNU_SOURCE");
747
748    DefineStd(Builder, "unix", Opts);
749    Builder.defineMacro("__ELF__");
750    Builder.defineMacro("__native_client__");
751  }
752
753public:
754  NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
755      : OSTargetInfo<Target>(Triple, Opts) {
756    this->LongAlign = 32;
757    this->LongWidth = 32;
758    this->PointerAlign = 32;
759    this->PointerWidth = 32;
760    this->IntMaxType = TargetInfo::SignedLongLong;
761    this->Int64Type = TargetInfo::SignedLongLong;
762    this->DoubleAlign = 64;
763    this->LongDoubleWidth = 64;
764    this->LongDoubleAlign = 64;
765    this->LongLongWidth = 64;
766    this->LongLongAlign = 64;
767    this->SizeType = TargetInfo::UnsignedInt;
768    this->PtrDiffType = TargetInfo::SignedInt;
769    this->IntPtrType = TargetInfo::SignedInt;
770    // RegParmMax is inherited from the underlying architecture.
771    this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
772    if (Triple.getArch() == llvm::Triple::arm) {
773      // Handled in ARM's setABI().
774    } else if (Triple.getArch() == llvm::Triple::x86) {
775      this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32-S128");
776    } else if (Triple.getArch() == llvm::Triple::x86_64) {
777      this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32:64-S128");
778    } else if (Triple.getArch() == llvm::Triple::mipsel) {
779      // Handled on mips' setDataLayout.
780    } else {
781      assert(Triple.getArch() == llvm::Triple::le32);
782      this->resetDataLayout("e-p:32:32-i64:64");
783    }
784  }
785};
786
787// Fuchsia Target
788template <typename Target>
789class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> {
790protected:
791  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
792                    MacroBuilder &Builder) const override {
793    Builder.defineMacro("__Fuchsia__");
794    Builder.defineMacro("__ELF__");
795    if (Opts.POSIXThreads)
796      Builder.defineMacro("_REENTRANT");
797    // Required by the libc++ locale support.
798    if (Opts.CPlusPlus)
799      Builder.defineMacro("_GNU_SOURCE");
800  }
801
802public:
803  FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
804      : OSTargetInfo<Target>(Triple, Opts) {
805    this->MCountName = "__mcount";
806  }
807};
808
809// WebAssembly target
810template <typename Target>
811class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo
812    : public OSTargetInfo<Target> {
813protected:
814  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
815                    MacroBuilder &Builder) const {
816    // A common platform macro.
817    if (Opts.POSIXThreads)
818      Builder.defineMacro("_REENTRANT");
819    // Follow g++ convention and predefine _GNU_SOURCE for C++.
820    if (Opts.CPlusPlus)
821      Builder.defineMacro("_GNU_SOURCE");
822    // Indicate that we have __float128.
823    Builder.defineMacro("__FLOAT128__");
824  }
825
826public:
827  explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple,
828                                   const TargetOptions &Opts)
829      : OSTargetInfo<Target>(Triple, Opts) {
830    this->MCountName = "__mcount";
831    this->TheCXXABI.set(TargetCXXABI::WebAssembly);
832    this->HasFloat128 = true;
833  }
834};
835
836// WASI target
837template <typename Target>
838class LLVM_LIBRARY_VISIBILITY WASITargetInfo
839    : public WebAssemblyOSTargetInfo<Target> {
840  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
841                    MacroBuilder &Builder) const final {
842    WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);
843    Builder.defineMacro("__wasi__");
844  }
845
846public:
847  explicit WASITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
848      : WebAssemblyOSTargetInfo<Target>(Triple, Opts) {}
849};
850
851} // namespace targets
852} // namespace clang
853#endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
854
clang::targets::AIXTargetInfo::getOSDefines
clang::targets::AIXTargetInfo::getFloatEvalMethod
clang::targets::AIXTargetInfo::hasInt128Type
clang::targets::AIXTargetInfo::getOSDefines
CodeThinker, Enjoy your reading code