clang  14.0.0git
TargetCXXABI.h
Go to the documentation of this file.
1 //===--- TargetCXXABI.h - C++ ABI Target Configuration ----------*- 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 /// \file
10 /// Defines the TargetCXXABI class, which abstracts details of the
11 /// C++ ABI that we're targeting.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_BASIC_TARGETCXXABI_H
16 #define LLVM_CLANG_BASIC_TARGETCXXABI_H
17 
18 #include <map>
19 
20 #include "clang/Basic/LLVM.h"
21 #include "llvm/ADT/StringMap.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/Support/ErrorHandling.h"
24 
25 namespace clang {
26 
27 /// The basic abstraction for the target C++ ABI.
28 class TargetCXXABI {
29 public:
30  /// The basic C++ ABI kind.
31  enum Kind {
32 #define CXXABI(Name, Str) Name,
33 #include "TargetCXXABI.def"
34  };
35 
36 private:
37  // Right now, this class is passed around as a cheap value type.
38  // If you add more members, especially non-POD members, please
39  // audit the users to pass it by reference instead.
40  Kind TheKind;
41 
42  static const auto &getABIMap() {
43  static llvm::StringMap<Kind> ABIMap = {
44 #define CXXABI(Name, Str) {Str, Name},
45 #include "TargetCXXABI.def"
46  };
47  return ABIMap;
48  }
49 
50  static const auto &getSpellingMap() {
51  static std::map<Kind, std::string> SpellingMap = {
52 #define CXXABI(Name, Str) {Name, Str},
53 #include "TargetCXXABI.def"
54  };
55  return SpellingMap;
56  }
57 
58 public:
59  static Kind getKind(StringRef Name) { return getABIMap().lookup(Name); }
60  static const auto &getSpelling(Kind ABIKind) {
61  return getSpellingMap().find(ABIKind)->second;
62  }
63  static bool isABI(StringRef Name) {
64  return getABIMap().find(Name) != getABIMap().end();
65  }
66 
67  // Return true if this target should use the relative vtables C++ ABI by
68  // default.
69  static bool usesRelativeVTables(const llvm::Triple &T) {
70  return T.isOSFuchsia();
71  }
72 
73  /// A bogus initialization of the platform ABI.
74  TargetCXXABI() : TheKind(GenericItanium) {}
75 
76  TargetCXXABI(Kind kind) : TheKind(kind) {}
77 
78  void set(Kind kind) {
79  TheKind = kind;
80  }
81 
82  Kind getKind() const { return TheKind; }
83 
84  // Check that the kind provided by the fc++-abi flag is supported on this
85  // target. Users who want to experiment using different ABIs on specific
86  // platforms can change this freely, but this function should be conservative
87  // enough such that not all ABIs are allowed on all platforms. For example, we
88  // probably don't want to allow usage of an ARM ABI on an x86 architecture.
89  static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind) {
90  switch (Kind) {
91  case GenericARM:
92  return T.isARM() || T.isAArch64();
93 
94  case iOS:
95  case WatchOS:
96  case AppleARM64:
97  return T.isOSDarwin();
98 
99  case Fuchsia:
100  return T.isOSFuchsia();
101 
102  case GenericAArch64:
103  return T.isAArch64();
104 
105  case GenericMIPS:
106  return T.isMIPS();
107 
108  case WebAssembly:
109  return T.isWasm();
110 
111  case XL:
112  return T.isOSAIX();
113 
114  case GenericItanium:
115  return true;
116 
117  case Microsoft:
118  return T.isKnownWindowsMSVCEnvironment();
119  }
120  llvm_unreachable("invalid CXXABI kind");
121  };
122 
123  /// Does this ABI generally fall into the Itanium family of ABIs?
124  bool isItaniumFamily() const {
125  switch (getKind()) {
126 #define CXXABI(Name, Str)
127 #define ITANIUM_CXXABI(Name, Str) case Name:
128 #include "TargetCXXABI.def"
129  return true;
130 
131  default:
132  return false;
133  }
134  llvm_unreachable("bad ABI kind");
135  }
136 
137  /// Is this ABI an MSVC-compatible ABI?
138  bool isMicrosoft() const {
139  switch (getKind()) {
140 #define CXXABI(Name, Str)
141 #define MICROSOFT_CXXABI(Name, Str) case Name:
142 #include "TargetCXXABI.def"
143  return true;
144 
145  default:
146  return false;
147  }
148  llvm_unreachable("bad ABI kind");
149  }
150 
151  /// Are member functions differently aligned?
152  ///
153  /// Many Itanium-style C++ ABIs require member functions to be aligned, so
154  /// that a pointer to such a function is guaranteed to have a zero in the
155  /// least significant bit, so that pointers to member functions can use that
156  /// bit to distinguish between virtual and non-virtual functions. However,
157  /// some Itanium-style C++ ABIs differentiate between virtual and non-virtual
158  /// functions via other means, and consequently don't require that member
159  /// functions be aligned.
161  switch (getKind()) {
162  case WebAssembly:
163  // WebAssembly doesn't require any special alignment for member functions.
164  return false;
165  case AppleARM64:
166  case Fuchsia:
167  case GenericARM:
168  case GenericAArch64:
169  case GenericMIPS:
170  // TODO: ARM-style pointers to member functions put the discriminator in
171  // the this adjustment, so they don't require functions to have any
172  // special alignment and could therefore also return false.
173  case GenericItanium:
174  case iOS:
175  case WatchOS:
176  case Microsoft:
177  case XL:
178  return true;
179  }
180  llvm_unreachable("bad ABI kind");
181  }
182 
183  /// Are arguments to a call destroyed left to right in the callee?
184  /// This is a fundamental language change, since it implies that objects
185  /// passed by value do *not* live to the end of the full expression.
186  /// Temporaries passed to a function taking a const reference live to the end
187  /// of the full expression as usual. Both the caller and the callee must
188  /// have access to the destructor, while only the caller needs the
189  /// destructor if this is false.
191  return isMicrosoft();
192  }
193 
194  /// Does this ABI have different entrypoints for complete-object
195  /// and base-subobject constructors?
196  bool hasConstructorVariants() const {
197  return isItaniumFamily();
198  }
199 
200  /// Does this ABI allow virtual bases to be primary base classes?
201  bool hasPrimaryVBases() const {
202  return isItaniumFamily();
203  }
204 
205  /// Does this ABI use key functions? If so, class data such as the
206  /// vtable is emitted with strong linkage by the TU containing the key
207  /// function.
208  bool hasKeyFunctions() const {
209  return isItaniumFamily();
210  }
211 
212  /// Can an out-of-line inline function serve as a key function?
213  ///
214  /// This flag is only useful in ABIs where type data (for example,
215  /// vtables and type_info objects) are emitted only after processing
216  /// the definition of a special "key" virtual function. (This is safe
217  /// because the ODR requires that every virtual function be defined
218  /// somewhere in a program.) This usually permits such data to be
219  /// emitted in only a single object file, as opposed to redundantly
220  /// in every object file that requires it.
221  ///
222  /// One simple and common definition of "key function" is the first
223  /// virtual function in the class definition which is not defined there.
224  /// This rule works very well when that function has a non-inline
225  /// definition in some non-header file. Unfortunately, when that
226  /// function is defined inline, this rule requires the type data
227  /// to be emitted weakly, as if there were no key function.
228  ///
229  /// The ARM ABI observes that the ODR provides an additional guarantee:
230  /// a virtual function is always ODR-used, so if it is defined inline,
231  /// that definition must appear in every translation unit that defines
232  /// the class. Therefore, there is no reason to allow such functions
233  /// to serve as key functions.
234  ///
235  /// Because this changes the rules for emitting type data,
236  /// it can cause type data to be emitted with both weak and strong
237  /// linkage, which is not allowed on all platforms. Therefore,
238  /// exploiting this observation requires an ABI break and cannot be
239  /// done on a generic Itanium platform.
240  bool canKeyFunctionBeInline() const {
241  switch (getKind()) {
242  case AppleARM64:
243  case Fuchsia:
244  case GenericARM:
245  case WebAssembly:
246  case WatchOS:
247  return false;
248 
249  case GenericAArch64:
250  case GenericItanium:
251  case iOS: // old iOS compilers did not follow this rule
252  case Microsoft:
253  case GenericMIPS:
254  case XL:
255  return true;
256  }
257  llvm_unreachable("bad ABI kind");
258  }
259 
260  /// When is record layout allowed to allocate objects in the tail
261  /// padding of a base class?
262  ///
263  /// This decision cannot be changed without breaking platform ABI
264  /// compatibility. In ISO C++98, tail padding reuse was only permitted for
265  /// non-POD base classes, but that restriction was removed retroactively by
266  /// DR 43, and tail padding reuse is always permitted in all de facto C++
267  /// language modes. However, many platforms use a variant of the old C++98
268  /// rule for compatibility.
270  /// The tail-padding of a base class is always theoretically
271  /// available, even if it's POD.
273 
274  /// Only allocate objects in the tail padding of a base class if
275  /// the base class is not POD according to the rules of C++ TR1.
277 
278  /// Only allocate objects in the tail padding of a base class if
279  /// the base class is not POD according to the rules of C++11.
281  };
283  switch (getKind()) {
284  // To preserve binary compatibility, the generic Itanium ABI has
285  // permanently locked the definition of POD to the rules of C++ TR1,
286  // and that trickles down to derived ABIs.
287  case GenericItanium:
288  case GenericAArch64:
289  case GenericARM:
290  case iOS:
291  case GenericMIPS:
292  case XL:
294 
295  // AppleARM64 and WebAssembly use the C++11 POD rules. They do not honor
296  // the Itanium exception about classes with over-large bitfields.
297  case AppleARM64:
298  case Fuchsia:
299  case WebAssembly:
300  case WatchOS:
302 
303  // MSVC always allocates fields in the tail-padding of a base class
304  // subobject, even if they're POD.
305  case Microsoft:
306  return AlwaysUseTailPadding;
307  }
308  llvm_unreachable("bad ABI kind");
309  }
310 
311  friend bool operator==(const TargetCXXABI &left, const TargetCXXABI &right) {
312  return left.getKind() == right.getKind();
313  }
314 
315  friend bool operator!=(const TargetCXXABI &left, const TargetCXXABI &right) {
316  return !(left == right);
317  }
318 };
319 
320 } // end namespace clang
321 
322 #endif
clang::TargetCXXABI::TailPaddingUseRules
TailPaddingUseRules
When is record layout allowed to allocate objects in the tail padding of a base class?
Definition: TargetCXXABI.h:269
clang::TargetCXXABI::isMicrosoft
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:138
clang::TargetCXXABI::hasKeyFunctions
bool hasKeyFunctions() const
Does this ABI use key functions? If so, class data such as the vtable is emitted with strong linkage ...
Definition: TargetCXXABI.h:208
clang::TargetCXXABI::operator!=
friend bool operator!=(const TargetCXXABI &left, const TargetCXXABI &right)
Definition: TargetCXXABI.h:315
clang::TargetCXXABI::isItaniumFamily
bool isItaniumFamily() const
Does this ABI generally fall into the Itanium family of ABIs?
Definition: TargetCXXABI.h:124
clang::TargetCXXABI::getTailPaddingUseRules
TailPaddingUseRules getTailPaddingUseRules() const
Definition: TargetCXXABI.h:282
clang::TargetCXXABI::getKind
static Kind getKind(StringRef Name)
Definition: TargetCXXABI.h:59
clang::TargetCXXABI::Kind
Kind
The basic C++ ABI kind.
Definition: TargetCXXABI.h:31
clang::TargetCXXABI::operator==
friend bool operator==(const TargetCXXABI &left, const TargetCXXABI &right)
Definition: TargetCXXABI.h:311
clang::TargetCXXABI::canKeyFunctionBeInline
bool canKeyFunctionBeInline() const
Can an out-of-line inline function serve as a key function?
Definition: TargetCXXABI.h:240
clang::TargetCXXABI::getKind
Kind getKind() const
Definition: TargetCXXABI.h:82
clang::TargetCXXABI::UseTailPaddingUnlessPOD11
@ UseTailPaddingUnlessPOD11
Only allocate objects in the tail padding of a base class if the base class is not POD according to t...
Definition: TargetCXXABI.h:280
clang::TargetCXXABI::TargetCXXABI
TargetCXXABI()
A bogus initialization of the platform ABI.
Definition: TargetCXXABI.h:74
clang::TargetCXXABI::isABI
static bool isABI(StringRef Name)
Definition: TargetCXXABI.h:63
clang::TargetCXXABI::UseTailPaddingUnlessPOD03
@ UseTailPaddingUnlessPOD03
Only allocate objects in the tail padding of a base class if the base class is not POD according to t...
Definition: TargetCXXABI.h:276
clang::TargetCXXABI::set
void set(Kind kind)
Definition: TargetCXXABI.h:78
clang::TargetCXXABI::isSupportedCXXABI
static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind)
Definition: TargetCXXABI.h:89
clang::TargetCXXABI::TargetCXXABI
TargetCXXABI(Kind kind)
Definition: TargetCXXABI.h:76
clang::AttrSyntax::Microsoft
@ Microsoft
Is the identifier known as a [] Microsoft-style attribute?
LLVM.h
clang::TargetCXXABI::AlwaysUseTailPadding
@ AlwaysUseTailPadding
The tail-padding of a base class is always theoretically available, even if it's POD.
Definition: TargetCXXABI.h:272
clang::TargetCXXABI::hasConstructorVariants
bool hasConstructorVariants() const
Does this ABI have different entrypoints for complete-object and base-subobject constructors?
Definition: TargetCXXABI.h:196
clang
Definition: CalledOnceCheck.h:17
clang::TargetCXXABI::hasPrimaryVBases
bool hasPrimaryVBases() const
Does this ABI allow virtual bases to be primary base classes?
Definition: TargetCXXABI.h:201
clang::TargetCXXABI::getSpelling
static const auto & getSpelling(Kind ABIKind)
Definition: TargetCXXABI.h:60
clang::TargetCXXABI::areArgsDestroyedLeftToRightInCallee
bool areArgsDestroyedLeftToRightInCallee() const
Are arguments to a call destroyed left to right in the callee? This is a fundamental language change,...
Definition: TargetCXXABI.h:190
clang::TargetCXXABI::areMemberFunctionsAligned
bool areMemberFunctionsAligned() const
Are member functions differently aligned?
Definition: TargetCXXABI.h:160
clang::diag::kind
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:62
clang::TargetCXXABI
The basic abstraction for the target C++ ABI.
Definition: TargetCXXABI.h:28
clang::TargetCXXABI::usesRelativeVTables
static bool usesRelativeVTables(const llvm::Triple &T)
Definition: TargetCXXABI.h:69