clang  10.0.0svn
ObjCRuntime.h
Go to the documentation of this file.
1 //===- ObjCRuntime.h - Objective-C Runtime 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 types useful for describing an Objective-C runtime.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_BASIC_OBJCRUNTIME_H
15 #define LLVM_CLANG_BASIC_OBJCRUNTIME_H
16 
17 #include "clang/Basic/LLVM.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/Triple.h"
20 #include "llvm/Support/ErrorHandling.h"
21 #include "llvm/Support/VersionTuple.h"
22 #include <string>
23 
24 namespace clang {
25 
26 /// The basic abstraction for the target Objective-C runtime.
27 class ObjCRuntime {
28 public:
29  /// The basic Objective-C runtimes that we know about.
30  enum Kind {
31  /// 'macosx' is the Apple-provided NeXT-derived runtime on Mac OS
32  /// X platforms that use the non-fragile ABI; the version is a
33  /// release of that OS.
35 
36  /// 'macosx-fragile' is the Apple-provided NeXT-derived runtime on
37  /// Mac OS X platforms that use the fragile ABI; the version is a
38  /// release of that OS.
40 
41  /// 'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS
42  /// simulator; it is always non-fragile. The version is a release
43  /// version of iOS.
44  iOS,
45 
46  /// 'watchos' is a variant of iOS for Apple's watchOS. The version
47  /// is a release version of watchOS.
49 
50  /// 'gcc' is the Objective-C runtime shipped with GCC, implementing a
51  /// fragile Objective-C ABI
52  GCC,
53 
54  /// 'gnustep' is the modern non-fragile GNUstep runtime.
56 
57  /// 'objfw' is the Objective-C runtime included in ObjFW
59  };
60 
61 private:
62  Kind TheKind = MacOSX;
63  VersionTuple Version;
64 
65 public:
66  /// A bogus initialization of the runtime.
67  ObjCRuntime() = default;
68  ObjCRuntime(Kind kind, const VersionTuple &version)
69  : TheKind(kind), Version(version) {}
70 
71  void set(Kind kind, VersionTuple version) {
72  TheKind = kind;
73  Version = version;
74  }
75 
76  Kind getKind() const { return TheKind; }
77  const VersionTuple &getVersion() const { return Version; }
78 
79  /// Does this runtime follow the set of implied behaviors for a
80  /// "non-fragile" ABI?
81  bool isNonFragile() const {
82  switch (getKind()) {
83  case FragileMacOSX: return false;
84  case GCC: return false;
85  case MacOSX: return true;
86  case GNUstep: return true;
87  case ObjFW: return true;
88  case iOS: return true;
89  case WatchOS: return true;
90  }
91  llvm_unreachable("bad kind");
92  }
93 
94  /// The inverse of isNonFragile(): does this runtime follow the set of
95  /// implied behaviors for a "fragile" ABI?
96  bool isFragile() const { return !isNonFragile(); }
97 
98  /// The default dispatch mechanism to use for the specified architecture
99  bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch) {
100  // The GNUstep runtime uses a newer dispatch method by default from
101  // version 1.6 onwards
102  if (getKind() == GNUstep && getVersion() >= VersionTuple(1, 6)) {
103  if (Arch == llvm::Triple::arm ||
104  Arch == llvm::Triple::x86 ||
105  Arch == llvm::Triple::x86_64)
106  return false;
107  }
108  else if ((getKind() == MacOSX) && isNonFragile() &&
109  (getVersion() >= VersionTuple(10, 0)) &&
110  (getVersion() < VersionTuple(10, 6)))
111  return Arch != llvm::Triple::x86_64;
112  // Except for deployment target of 10.5 or less,
113  // Mac runtimes use legacy dispatch everywhere now.
114  return true;
115  }
116 
117  /// Is this runtime basically of the GNU family of runtimes?
118  bool isGNUFamily() const {
119  switch (getKind()) {
120  case FragileMacOSX:
121  case MacOSX:
122  case iOS:
123  case WatchOS:
124  return false;
125  case GCC:
126  case GNUstep:
127  case ObjFW:
128  return true;
129  }
130  llvm_unreachable("bad kind");
131  }
132 
133  /// Is this runtime basically of the NeXT family of runtimes?
134  bool isNeXTFamily() const {
135  // For now, this is just the inverse of isGNUFamily(), but that's
136  // not inherently true.
137  return !isGNUFamily();
138  }
139 
140  /// Does this runtime allow ARC at all?
141  bool allowsARC() const {
142  switch (getKind()) {
143  case FragileMacOSX:
144  // No stub library for the fragile runtime.
145  return getVersion() >= VersionTuple(10, 7);
146  case MacOSX: return true;
147  case iOS: return true;
148  case WatchOS: return true;
149  case GCC: return false;
150  case GNUstep: return true;
151  case ObjFW: return true;
152  }
153  llvm_unreachable("bad kind");
154  }
155 
156  /// Does this runtime natively provide the ARC entrypoints?
157  ///
158  /// ARC cannot be directly supported on a platform that does not provide
159  /// these entrypoints, although it may be supportable via a stub
160  /// library.
161  bool hasNativeARC() const {
162  switch (getKind()) {
163  case FragileMacOSX: return getVersion() >= VersionTuple(10, 7);
164  case MacOSX: return getVersion() >= VersionTuple(10, 7);
165  case iOS: return getVersion() >= VersionTuple(5);
166  case WatchOS: return true;
167 
168  case GCC: return false;
169  case GNUstep: return getVersion() >= VersionTuple(1, 6);
170  case ObjFW: return true;
171  }
172  llvm_unreachable("bad kind");
173  }
174 
175  /// Does this runtime provide ARC entrypoints that are likely to be faster
176  /// than an ordinary message send of the appropriate selector?
177  ///
178  /// The ARC entrypoints are guaranteed to be equivalent to just sending the
179  /// corresponding message. If the entrypoint is implemented naively as just a
180  /// message send, using it is a trade-off: it sacrifices a few cycles of
181  /// overhead to save a small amount of code. However, it's possible for
182  /// runtimes to detect and special-case classes that use "standard"
183  /// retain/release behavior; if that's dynamically a large proportion of all
184  /// retained objects, using the entrypoint will also be faster than using a
185  /// message send.
186  ///
187  /// When this method returns true, Clang will turn non-super message sends of
188  /// certain selectors into calls to the correspond entrypoint:
189  /// retain => objc_retain
190  /// release => objc_release
191  /// autorelease => objc_autorelease
193  switch (getKind()) {
194  case FragileMacOSX:
195  return false;
196  case MacOSX:
197  return getVersion() >= VersionTuple(10, 10);
198  case iOS:
199  return getVersion() >= VersionTuple(8);
200  case WatchOS:
201  return true;
202  case GCC:
203  return false;
204  case GNUstep:
205  return false;
206  case ObjFW:
207  return false;
208  }
209  llvm_unreachable("bad kind");
210  }
211 
212  /// Does this runtime provide entrypoints that are likely to be faster
213  /// than an ordinary message send of the "alloc" selector?
214  ///
215  /// The "alloc" entrypoint is guaranteed to be equivalent to just sending the
216  /// corresponding message. If the entrypoint is implemented naively as just a
217  /// message send, using it is a trade-off: it sacrifices a few cycles of
218  /// overhead to save a small amount of code. However, it's possible for
219  /// runtimes to detect and special-case classes that use "standard"
220  /// alloc behavior; if that's dynamically a large proportion of all
221  /// objects, using the entrypoint will also be faster than using a message
222  /// send.
223  ///
224  /// When this method returns true, Clang will turn non-super message sends of
225  /// certain selectors into calls to the corresponding entrypoint:
226  /// alloc => objc_alloc
227  /// allocWithZone:nil => objc_allocWithZone
229  switch (getKind()) {
230  case FragileMacOSX:
231  return false;
232  case MacOSX:
233  return getVersion() >= VersionTuple(10, 10);
234  case iOS:
235  return getVersion() >= VersionTuple(8);
236  case WatchOS:
237  return true;
238 
239  case GCC:
240  return false;
241  case GNUstep:
242  return false;
243  case ObjFW:
244  return false;
245  }
246  llvm_unreachable("bad kind");
247  }
248 
249  /// Does this runtime provide the objc_alloc_init entrypoint? This can apply
250  /// the same optimization as objc_alloc, but also sends an -init message,
251  /// reducing code size on the caller.
253  switch (getKind()) {
254  case MacOSX:
255  return getVersion() >= VersionTuple(10, 14, 4);
256  case iOS:
257  return getVersion() >= VersionTuple(12, 2);
258  case WatchOS:
259  return getVersion() >= VersionTuple(5, 2);
260  default:
261  return false;
262  }
263  }
264 
265  /// Does this runtime supports optimized setter entrypoints?
266  bool hasOptimizedSetter() const {
267  switch (getKind()) {
268  case MacOSX:
269  return getVersion() >= VersionTuple(10, 8);
270  case iOS:
271  return (getVersion() >= VersionTuple(6));
272  case WatchOS:
273  return true;
274  case GNUstep:
275  return getVersion() >= VersionTuple(1, 7);
276  default:
277  return false;
278  }
279  }
280 
281  /// Does this runtime allow the use of __weak?
282  bool allowsWeak() const {
283  return hasNativeWeak();
284  }
285 
286  /// Does this runtime natively provide ARC-compliant 'weak'
287  /// entrypoints?
288  bool hasNativeWeak() const {
289  // Right now, this is always equivalent to whether the runtime
290  // natively supports ARC decision.
291  return hasNativeARC();
292  }
293 
294  /// Does this runtime directly support the subscripting methods?
295  ///
296  /// This is really a property of the library, not the runtime.
297  bool hasSubscripting() const {
298  switch (getKind()) {
299  case FragileMacOSX: return false;
300  case MacOSX: return getVersion() >= VersionTuple(10, 11);
301  case iOS: return getVersion() >= VersionTuple(9);
302  case WatchOS: return true;
303 
304  // This is really a lie, because some implementations and versions
305  // of the runtime do not support ARC. Probably -fgnu-runtime
306  // should imply a "maximal" runtime or something?
307  case GCC: return true;
308  case GNUstep: return true;
309  case ObjFW: return true;
310  }
311  llvm_unreachable("bad kind");
312  }
313 
314  /// Does this runtime allow sizeof or alignof on object types?
315  bool allowsSizeofAlignof() const {
316  return isFragile();
317  }
318 
319  /// Does this runtime allow pointer arithmetic on objects?
320  ///
321  /// This covers +, -, ++, --, and (if isSubscriptPointerArithmetic()
322  /// yields true) [].
323  bool allowsPointerArithmetic() const {
324  switch (getKind()) {
325  case FragileMacOSX:
326  case GCC:
327  return true;
328  case MacOSX:
329  case iOS:
330  case WatchOS:
331  case GNUstep:
332  case ObjFW:
333  return false;
334  }
335  llvm_unreachable("bad kind");
336  }
337 
338  /// Is subscripting pointer arithmetic?
340  return allowsPointerArithmetic();
341  }
342 
343  /// Does this runtime provide an objc_terminate function?
344  ///
345  /// This is used in handlers for exceptions during the unwind process;
346  /// without it, abort() must be used in pure ObjC files.
347  bool hasTerminate() const {
348  switch (getKind()) {
349  case FragileMacOSX: return getVersion() >= VersionTuple(10, 8);
350  case MacOSX: return getVersion() >= VersionTuple(10, 8);
351  case iOS: return getVersion() >= VersionTuple(5);
352  case WatchOS: return true;
353  case GCC: return false;
354  case GNUstep: return false;
355  case ObjFW: return false;
356  }
357  llvm_unreachable("bad kind");
358  }
359 
360  /// Does this runtime support weakly importing classes?
361  bool hasWeakClassImport() const {
362  switch (getKind()) {
363  case MacOSX: return true;
364  case iOS: return true;
365  case WatchOS: return true;
366  case FragileMacOSX: return false;
367  case GCC: return true;
368  case GNUstep: return true;
369  case ObjFW: return true;
370  }
371  llvm_unreachable("bad kind");
372  }
373 
374  /// Does this runtime use zero-cost exceptions?
375  bool hasUnwindExceptions() const {
376  switch (getKind()) {
377  case MacOSX: return true;
378  case iOS: return true;
379  case WatchOS: return true;
380  case FragileMacOSX: return false;
381  case GCC: return true;
382  case GNUstep: return true;
383  case ObjFW: return true;
384  }
385  llvm_unreachable("bad kind");
386  }
387 
388  bool hasAtomicCopyHelper() const {
389  switch (getKind()) {
390  case FragileMacOSX:
391  case MacOSX:
392  case iOS:
393  case WatchOS:
394  return true;
395  case GNUstep:
396  return getVersion() >= VersionTuple(1, 7);
397  default: return false;
398  }
399  }
400 
401  /// Is objc_unsafeClaimAutoreleasedReturnValue available?
403  switch (getKind()) {
404  case MacOSX:
405  case FragileMacOSX:
406  return getVersion() >= VersionTuple(10, 11);
407  case iOS:
408  return getVersion() >= VersionTuple(9);
409  case WatchOS:
410  return getVersion() >= VersionTuple(2);
411  case GNUstep:
412  return false;
413  default:
414  return false;
415  }
416  }
417 
418  /// Are the empty collection symbols available?
419  bool hasEmptyCollections() const {
420  switch (getKind()) {
421  default:
422  return false;
423  case MacOSX:
424  return getVersion() >= VersionTuple(10, 11);
425  case iOS:
426  return getVersion() >= VersionTuple(9);
427  case WatchOS:
428  return getVersion() >= VersionTuple(2);
429  }
430  }
431 
432  /// Returns true if this Objective-C runtime supports Objective-C class
433  /// stubs.
434  bool allowsClassStubs() const {
435  switch (getKind()) {
436  case FragileMacOSX:
437  case GCC:
438  case GNUstep:
439  case ObjFW:
440  return false;
441  case MacOSX:
442  case iOS:
443  case WatchOS:
444  return true;
445  }
446  llvm_unreachable("bad kind");
447  }
448 
449  /// Try to parse an Objective-C runtime specification from the given
450  /// string.
451  ///
452  /// \return true on error.
453  bool tryParse(StringRef input);
454 
455  std::string getAsString() const;
456 
457  friend bool operator==(const ObjCRuntime &left, const ObjCRuntime &right) {
458  return left.getKind() == right.getKind() &&
459  left.getVersion() == right.getVersion();
460  }
461 
462  friend bool operator!=(const ObjCRuntime &left, const ObjCRuntime &right) {
463  return !(left == right);
464  }
465 };
466 
467 raw_ostream &operator<<(raw_ostream &out, const ObjCRuntime &value);
468 
469 } // namespace clang
470 
471 #endif // LLVM_CLANG_BASIC_OBJCRUNTIME_H
bool shouldUseRuntimeFunctionsForAlloc() const
Does this runtime provide entrypoints that are likely to be faster than an ordinary message send of t...
Definition: ObjCRuntime.h:228
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:334
bool allowsPointerArithmetic() const
Does this runtime allow pointer arithmetic on objects?
Definition: ObjCRuntime.h:323
&#39;gcc&#39; is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
Definition: ObjCRuntime.h:52
bool allowsClassStubs() const
Returns true if this Objective-C runtime supports Objective-C class stubs.
Definition: ObjCRuntime.h:434
bool hasWeakClassImport() const
Does this runtime support weakly importing classes?
Definition: ObjCRuntime.h:361
&#39;macosx-fragile&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition: ObjCRuntime.h:39
bool hasOptimizedSetter() const
Does this runtime supports optimized setter entrypoints?
Definition: ObjCRuntime.h:266
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:81
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:134
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
&#39;watchos&#39; is a variant of iOS for Apple&#39;s watchOS.
Definition: ObjCRuntime.h:48
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
Definition: ObjCRuntime.h:96
bool isSubscriptPointerArithmetic() const
Is subscripting pointer arithmetic?
Definition: ObjCRuntime.h:339
bool isGNUFamily() const
Is this runtime basically of the GNU family of runtimes?
Definition: ObjCRuntime.h:118
bool hasAtomicCopyHelper() const
Definition: ObjCRuntime.h:388
&#39;macosx&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition: ObjCRuntime.h:34
std::string getAsString() const
Definition: ObjCRuntime.cpp:23
bool allowsSizeofAlignof() const
Does this runtime allow sizeof or alignof on object types?
Definition: ObjCRuntime.h:315
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
Definition: ObjCRuntime.cpp:48
bool hasTerminate() const
Does this runtime provide an objc_terminate function?
Definition: ObjCRuntime.h:347
ObjCRuntime()=default
A bogus initialization of the runtime.
ObjCRuntime(Kind kind, const VersionTuple &version)
Definition: ObjCRuntime.h:68
&#39;gnustep&#39; is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:55
bool hasEmptyCollections() const
Are the empty collection symbols available?
Definition: ObjCRuntime.h:419
bool hasNativeWeak() const
Does this runtime natively provide ARC-compliant &#39;weak&#39; entrypoints?
Definition: ObjCRuntime.h:288
bool shouldUseRuntimeFunctionForCombinedAllocInit() const
Does this runtime provide the objc_alloc_init entrypoint? This can apply the same optimization as obj...
Definition: ObjCRuntime.h:252
&#39;objfw&#39; is the Objective-C runtime included in ObjFW
Definition: ObjCRuntime.h:58
Kind getKind() const
Definition: ObjCRuntime.h:76
bool hasUnwindExceptions() const
Does this runtime use zero-cost exceptions?
Definition: ObjCRuntime.h:375
bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch)
The default dispatch mechanism to use for the specified architecture.
Definition: ObjCRuntime.h:99
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:77
bool allowsARC() const
Does this runtime allow ARC at all?
Definition: ObjCRuntime.h:141
Dataflow Directional Tag Classes.
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:27
friend bool operator!=(const ObjCRuntime &left, const ObjCRuntime &right)
Definition: ObjCRuntime.h:462
&#39;ios&#39; is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
Definition: ObjCRuntime.h:44
friend bool operator==(const ObjCRuntime &left, const ObjCRuntime &right)
Definition: ObjCRuntime.h:457
bool shouldUseARCFunctionsForRetainRelease() const
Does this runtime provide ARC entrypoints that are likely to be faster than an ordinary message send ...
Definition: ObjCRuntime.h:192
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:60
bool hasARCUnsafeClaimAutoreleasedReturnValue() const
Is objc_unsafeClaimAutoreleasedReturnValue available?
Definition: ObjCRuntime.h:402
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
Definition: ObjCRuntime.h:161
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
Definition: ObjCRuntime.h:297
Kind
The basic Objective-C runtimes that we know about.
Definition: ObjCRuntime.h:30
bool allowsWeak() const
Does this runtime allow the use of __weak?
Definition: ObjCRuntime.h:282