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