clang 17.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
25namespace clang {
26
27/// The basic abstraction for the target C++ ABI.
29public:
30 /// The basic C++ ABI kind.
31 enum Kind {
32#define CXXABI(Name, Str) Name,
33#include "TargetCXXABI.def"
34 };
35
36private:
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
58public:
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?
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.
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:
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
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
The basic abstraction for the target C++ ABI.
Definition: TargetCXXABI.h:28
TargetCXXABI()
A bogus initialization of the platform ABI.
Definition: TargetCXXABI.h:74
static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind)
Definition: TargetCXXABI.h:89
static const auto & getSpelling(Kind ABIKind)
Definition: TargetCXXABI.h:60
TargetCXXABI(Kind kind)
Definition: TargetCXXABI.h:76
static bool usesRelativeVTables(const llvm::Triple &T)
Definition: TargetCXXABI.h:69
TailPaddingUseRules getTailPaddingUseRules() const
Definition: TargetCXXABI.h:282
bool hasConstructorVariants() const
Does this ABI have different entrypoints for complete-object and base-subobject constructors?
Definition: TargetCXXABI.h:196
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
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:138
bool hasPrimaryVBases() const
Does this ABI allow virtual bases to be primary base classes?
Definition: TargetCXXABI.h:201
static bool isABI(StringRef Name)
Definition: TargetCXXABI.h:63
bool canKeyFunctionBeInline() const
Can an out-of-line inline function serve as a key function?
Definition: TargetCXXABI.h:240
Kind getKind() const
Definition: TargetCXXABI.h:82
friend bool operator==(const TargetCXXABI &left, const TargetCXXABI &right)
Definition: TargetCXXABI.h:311
void set(Kind kind)
Definition: TargetCXXABI.h:78
TailPaddingUseRules
When is record layout allowed to allocate objects in the tail padding of a base class?
Definition: TargetCXXABI.h:269
@ AlwaysUseTailPadding
The tail-padding of a base class is always theoretically available, even if it's POD.
Definition: TargetCXXABI.h:272
@ 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
@ 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
bool isItaniumFamily() const
Does this ABI generally fall into the Itanium family of ABIs?
Definition: TargetCXXABI.h:124
bool areMemberFunctionsAligned() const
Are member functions differently aligned?
Definition: TargetCXXABI.h:160
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
Kind
The basic C++ ABI kind.
Definition: TargetCXXABI.h:31
static Kind getKind(StringRef Name)
Definition: TargetCXXABI.h:59
friend bool operator!=(const TargetCXXABI &left, const TargetCXXABI &right)
Definition: TargetCXXABI.h:315