clang  3.7.0
ObjCRuntime.h
Go to the documentation of this file.
1 //===--- ObjCRuntime.h - Objective-C Runtime Configuration ------*- 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 /// \file
11 /// \brief Defines types useful for describing an Objective-C runtime.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_BASIC_OBJCRUNTIME_H
16 #define LLVM_CLANG_BASIC_OBJCRUNTIME_H
17 
19 #include "llvm/ADT/Triple.h"
20 #include "llvm/Support/ErrorHandling.h"
21 
22 namespace clang {
23 
24 /// \brief The basic abstraction for the target Objective-C runtime.
25 class ObjCRuntime {
26 public:
27  /// \brief The basic Objective-C runtimes that we know about.
28  enum Kind {
29  /// 'macosx' is the Apple-provided NeXT-derived runtime on Mac OS
30  /// X platforms that use the non-fragile ABI; the version is a
31  /// release of that OS.
33 
34  /// 'macosx-fragile' is the Apple-provided NeXT-derived runtime on
35  /// Mac OS X platforms that use the fragile ABI; the version is a
36  /// release of that OS.
38 
39  /// 'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS
40  /// simulator; it is always non-fragile. The version is a release
41  /// version of iOS.
42  iOS,
43 
44  /// 'gcc' is the Objective-C runtime shipped with GCC, implementing a
45  /// fragile Objective-C ABI
46  GCC,
47 
48  /// 'gnustep' is the modern non-fragile GNUstep runtime.
50 
51  /// 'objfw' is the Objective-C runtime included in ObjFW
53  };
54 
55 private:
56  Kind TheKind;
57  VersionTuple Version;
58 
59 public:
60  /// A bogus initialization of the runtime.
61  ObjCRuntime() : TheKind(MacOSX) {}
62 
63  ObjCRuntime(Kind kind, const VersionTuple &version)
64  : TheKind(kind), Version(version) {}
65 
66  void set(Kind kind, VersionTuple version) {
67  TheKind = kind;
68  Version = version;
69  }
70 
71  Kind getKind() const { return TheKind; }
72  const VersionTuple &getVersion() const { return Version; }
73 
74  /// \brief Does this runtime follow the set of implied behaviors for a
75  /// "non-fragile" ABI?
76  bool isNonFragile() const {
77  switch (getKind()) {
78  case FragileMacOSX: return false;
79  case GCC: return false;
80  case MacOSX: return true;
81  case GNUstep: return true;
82  case ObjFW: return true;
83  case iOS: return true;
84  }
85  llvm_unreachable("bad kind");
86  }
87 
88  /// The inverse of isNonFragile(): does this runtime follow the set of
89  /// implied behaviors for a "fragile" ABI?
90  bool isFragile() const { return !isNonFragile(); }
91 
92  /// The default dispatch mechanism to use for the specified architecture
93  bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch) {
94  // The GNUstep runtime uses a newer dispatch method by default from
95  // version 1.6 onwards
96  if (getKind() == GNUstep && getVersion() >= VersionTuple(1, 6)) {
97  if (Arch == llvm::Triple::arm ||
98  Arch == llvm::Triple::x86 ||
99  Arch == llvm::Triple::x86_64)
100  return false;
101  }
102  else if ((getKind() == MacOSX) && isNonFragile() &&
103  (getVersion() >= VersionTuple(10, 0)) &&
104  (getVersion() < VersionTuple(10, 6)))
105  return Arch != llvm::Triple::x86_64;
106  // Except for deployment target of 10.5 or less,
107  // Mac runtimes use legacy dispatch everywhere now.
108  return true;
109  }
110 
111  /// \brief Is this runtime basically of the GNU family of runtimes?
112  bool isGNUFamily() const {
113  switch (getKind()) {
114  case FragileMacOSX:
115  case MacOSX:
116  case iOS:
117  return false;
118  case GCC:
119  case GNUstep:
120  case ObjFW:
121  return true;
122  }
123  llvm_unreachable("bad kind");
124  }
125 
126  /// \brief Is this runtime basically of the NeXT family of runtimes?
127  bool isNeXTFamily() const {
128  // For now, this is just the inverse of isGNUFamily(), but that's
129  // not inherently true.
130  return !isGNUFamily();
131  }
132 
133  /// \brief Does this runtime allow ARC at all?
134  bool allowsARC() const {
135  switch (getKind()) {
136  case FragileMacOSX: return false;
137  case MacOSX: return true;
138  case iOS: return true;
139  case GCC: return false;
140  case GNUstep: return true;
141  case ObjFW: return true;
142  }
143  llvm_unreachable("bad kind");
144  }
145 
146  /// \brief Does this runtime natively provide the ARC entrypoints?
147  ///
148  /// ARC cannot be directly supported on a platform that does not provide
149  /// these entrypoints, although it may be supportable via a stub
150  /// library.
151  bool hasNativeARC() const {
152  switch (getKind()) {
153  case FragileMacOSX: return false;
154  case MacOSX: return getVersion() >= VersionTuple(10, 7);
155  case iOS: return getVersion() >= VersionTuple(5);
156 
157  case GCC: return false;
158  case GNUstep: return getVersion() >= VersionTuple(1, 6);
159  case ObjFW: return true;
160  }
161  llvm_unreachable("bad kind");
162  }
163 
164  /// \brief Does this runtime supports optimized setter entrypoints?
165  bool hasOptimizedSetter() const {
166  switch (getKind()) {
167  case MacOSX:
168  return getVersion() >= VersionTuple(10, 8);
169  case iOS:
170  return (getVersion() >= VersionTuple(6));
171  case GNUstep:
172  return getVersion() >= VersionTuple(1, 7);
173 
174  default:
175  return false;
176  }
177  }
178 
179  /// Does this runtime allow the use of __weak?
180  bool allowsWeak() const {
181  return hasNativeWeak();
182  }
183 
184  /// \brief Does this runtime natively provide ARC-compliant 'weak'
185  /// entrypoints?
186  bool hasNativeWeak() const {
187  // Right now, this is always equivalent to whether the runtime
188  // natively supports ARC decision.
189  return hasNativeARC();
190  }
191 
192  /// \brief Does this runtime directly support the subscripting methods?
193  ///
194  /// This is really a property of the library, not the runtime.
195  bool hasSubscripting() const {
196  switch (getKind()) {
197  case FragileMacOSX: return false;
198  case MacOSX: return getVersion() >= VersionTuple(10, 8);
199  case iOS: return getVersion() >= VersionTuple(6);
200 
201  // This is really a lie, because some implementations and versions
202  // of the runtime do not support ARC. Probably -fgnu-runtime
203  // should imply a "maximal" runtime or something?
204  case GCC: return true;
205  case GNUstep: return true;
206  case ObjFW: return true;
207  }
208  llvm_unreachable("bad kind");
209  }
210 
211  /// \brief Does this runtime allow sizeof or alignof on object types?
212  bool allowsSizeofAlignof() const {
213  return isFragile();
214  }
215 
216  /// \brief Does this runtime allow pointer arithmetic on objects?
217  ///
218  /// This covers +, -, ++, --, and (if isSubscriptPointerArithmetic()
219  /// yields true) [].
220  bool allowsPointerArithmetic() const {
221  switch (getKind()) {
222  case FragileMacOSX:
223  case GCC:
224  return true;
225  case MacOSX:
226  case iOS:
227  case GNUstep:
228  case ObjFW:
229  return false;
230  }
231  llvm_unreachable("bad kind");
232  }
233 
234  /// \brief Is subscripting pointer arithmetic?
236  return allowsPointerArithmetic();
237  }
238 
239  /// \brief Does this runtime provide an objc_terminate function?
240  ///
241  /// This is used in handlers for exceptions during the unwind process;
242  /// without it, abort() must be used in pure ObjC files.
243  bool hasTerminate() const {
244  switch (getKind()) {
245  case FragileMacOSX: return getVersion() >= VersionTuple(10, 8);
246  case MacOSX: return getVersion() >= VersionTuple(10, 8);
247  case iOS: return getVersion() >= VersionTuple(5);
248  case GCC: return false;
249  case GNUstep: return false;
250  case ObjFW: return false;
251  }
252  llvm_unreachable("bad kind");
253  }
254 
255  /// \brief Does this runtime support weakly importing classes?
256  bool hasWeakClassImport() const {
257  switch (getKind()) {
258  case MacOSX: return true;
259  case iOS: return true;
260  case FragileMacOSX: return false;
261  case GCC: return true;
262  case GNUstep: return true;
263  case ObjFW: return true;
264  }
265  llvm_unreachable("bad kind");
266  }
267 
268  /// \brief Does this runtime use zero-cost exceptions?
269  bool hasUnwindExceptions() const {
270  switch (getKind()) {
271  case MacOSX: return true;
272  case iOS: return true;
273  case FragileMacOSX: return false;
274  case GCC: return true;
275  case GNUstep: return true;
276  case ObjFW: return true;
277  }
278  llvm_unreachable("bad kind");
279  }
280 
281  bool hasAtomicCopyHelper() const {
282  switch (getKind()) {
283  case FragileMacOSX:
284  case MacOSX:
285  case iOS:
286  return true;
287  case GNUstep:
288  return getVersion() >= VersionTuple(1, 7);
289  default: return false;
290  }
291  }
292 
293  /// \brief Try to parse an Objective-C runtime specification from the given
294  /// string.
295  ///
296  /// \return true on error.
297  bool tryParse(StringRef input);
298 
299  std::string getAsString() const;
300 
301  friend bool operator==(const ObjCRuntime &left, const ObjCRuntime &right) {
302  return left.getKind() == right.getKind() &&
303  left.getVersion() == right.getVersion();
304  }
305 
306  friend bool operator!=(const ObjCRuntime &left, const ObjCRuntime &right) {
307  return !(left == right);
308  }
309 };
310 
311 raw_ostream &operator<<(raw_ostream &out, const ObjCRuntime &value);
312 
313 } // end namespace clang
314 
315 #endif
bool allowsSizeofAlignof() const
Does this runtime allow sizeof or alignof on object types?
Definition: ObjCRuntime.h:212
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:154
bool allowsWeak() const
Does this runtime allow the use of __weak?
Definition: ObjCRuntime.h:180
bool allowsARC() const
Does this runtime allow ARC at all?
Definition: ObjCRuntime.h:134
bool hasOptimizedSetter() const
Does this runtime supports optimized setter entrypoints?
Definition: ObjCRuntime.h:165
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
Definition: ObjCRuntime.h:151
ObjCRuntime()
A bogus initialization of the runtime.
Definition: ObjCRuntime.h:61
bool hasUnwindExceptions() const
Does this runtime use zero-cost exceptions?
Definition: ObjCRuntime.h:269
bool hasTerminate() const
Does this runtime provide an objc_terminate function?
Definition: ObjCRuntime.h:243
bool hasWeakClassImport() const
Does this runtime support weakly importing classes?
Definition: ObjCRuntime.h:256
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:127
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
Definition: ObjCRuntime.cpp:43
bool hasNativeWeak() const
Does this runtime natively provide ARC-compliant 'weak' entrypoints?
Definition: ObjCRuntime.h:186
ObjCRuntime(Kind kind, const VersionTuple &version)
Definition: ObjCRuntime.h:63
'gnustep' is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:49
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:76
Kind
void set(Kind kind, VersionTuple version)
Definition: ObjCRuntime.h:66
'objfw' is the Objective-C runtime included in ObjFW
Definition: ObjCRuntime.h:52
bool isGNUFamily() const
Is this runtime basically of the GNU family of runtimes?
Definition: ObjCRuntime.h:112
bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch)
The default dispatch mechanism to use for the specified architecture.
Definition: ObjCRuntime.h:93
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:72
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
Definition: ObjCRuntime.h:195
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
friend bool operator!=(const ObjCRuntime &left, const ObjCRuntime &right)
Definition: ObjCRuntime.h:306
bool isSubscriptPointerArithmetic() const
Is subscripting pointer arithmetic?
Definition: ObjCRuntime.h:235
friend bool operator==(const ObjCRuntime &left, const ObjCRuntime &right)
Definition: ObjCRuntime.h:301
Kind getKind() const
Definition: ObjCRuntime.h:71
bool hasAtomicCopyHelper() const
Definition: ObjCRuntime.h:281
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:43
Defines the clang::VersionTuple class, which represents a version in the form major[.minor[.subminor]].
bool isFragile() const
Definition: ObjCRuntime.h:90
std::string getAsString() const
Definition: ObjCRuntime.cpp:19
Kind
The basic Objective-C runtimes that we know about.
Definition: ObjCRuntime.h:28
bool allowsPointerArithmetic() const
Does this runtime allow pointer arithmetic on objects?
Definition: ObjCRuntime.h:220