clang 8.0.0

CGObjCMac.cpp
Go to the documentation of this file.
1 //===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
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 provides Objective-C code generation targeting the Apple runtime.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "CGBlocks.h"
15 #include "CGCleanup.h"
16 #include "CGObjCRuntime.h"
17 #include "CGRecordLayout.h"
18 #include "CodeGenFunction.h"
19 #include "CodeGenModule.h"
20 #include "clang/CodeGen/ConstantInitBuilder.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/Decl.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/StmtObjC.h"
26 #include "clang/Basic/CodeGenOptions.h"
27 #include "clang/Basic/LangOptions.h"
28 #include "clang/CodeGen/CGFunctionInfo.h"
29 #include "llvm/ADT/CachedHashString.h"
30 #include "llvm/ADT/DenseSet.h"
31 #include "llvm/ADT/SetVector.h"
32 #include "llvm/ADT/SmallPtrSet.h"
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/IR/CallSite.h"
35 #include "llvm/IR/DataLayout.h"
36 #include "llvm/IR/InlineAsm.h"
37 #include "llvm/IR/IntrinsicInst.h"
38 #include "llvm/IR/LLVMContext.h"
39 #include "llvm/IR/Module.h"
40 #include "llvm/Support/ScopedPrinter.h"
41 #include "llvm/Support/raw_ostream.h"
42 #include <cstdio>
43
44 using namespace clang;
45 using namespace CodeGen;
46
47 namespace {
48
49 // FIXME: We should find a nicer way to make the labels for metadata, string
50 // concatenation is lame.
51
52 class ObjCCommonTypesHelper {
53 protected:
54 llvm::LLVMContext &VMContext;
55
56 private:
57 // The types of these functions don't really matter because we
58 // should always bitcast before calling them.
59
60 /// id objc_msgSend (id, SEL, ...)
61 ///
62 /// The default messenger, used for sends whose ABI is unchanged from
63 /// the all-integer/pointer case.
64 llvm::Constant *getMessageSendFn() const {
65 // Add the non-lazy-bind attribute, since objc_msgSend is likely to
66 // be called a lot.
67 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
68 return CGM.CreateRuntimeFunction(
69 llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
70 llvm::AttributeList::get(CGM.getLLVMContext(),
71 llvm::AttributeList::FunctionIndex,
72 llvm::Attribute::NonLazyBind));
73 }
74
75 /// void objc_msgSend_stret (id, SEL, ...)
76 ///
77 /// The messenger used when the return value is an aggregate returned
78 /// by indirect reference in the first argument, and therefore the
79 /// self and selector parameters are shifted over by one.
80 llvm::Constant *getMessageSendStretFn() const {
81 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
82 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
83 params, true),
84 "objc_msgSend_stret");
85
86 }
87
88 /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
89 ///
90 /// The messenger used when the return value is returned on the x87
91 /// floating-point stack; without a special entrypoint, the nil case
92 /// would be unbalanced.
93 llvm::Constant *getMessageSendFpretFn() const {
94 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
95 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
96 params, true),
97 "objc_msgSend_fpret");
98
99 }
100
101 /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
102 ///
103 /// The messenger used when the return value is returned in two values on the
104 /// x87 floating point stack; without a special entrypoint, the nil case
105 /// would be unbalanced. Only used on 64-bit X86.
106 llvm::Constant *getMessageSendFp2retFn() const {
107 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
108 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
109 llvm::Type *resultType =
110 llvm::StructType::get(longDoubleType, longDoubleType);
111
112 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
113 params, true),
114 "objc_msgSend_fp2ret");
115 }
116
117 /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
118 ///
119 /// The messenger used for super calls, which have different dispatch
120 /// semantics. The class passed is the superclass of the current
121 /// class.
122 llvm::Constant *getMessageSendSuperFn() const {
123 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
124 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
125 params, true),
126 "objc_msgSendSuper");
127 }
128
129 /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
130 ///
131 /// A slightly different messenger used for super calls. The class
132 /// passed is the current class.
133 llvm::Constant *getMessageSendSuperFn2() const {
134 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
135 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
136 params, true),
137 "objc_msgSendSuper2");
138 }
139
140 /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
141 /// SEL op, ...)
142 ///
143 /// The messenger used for super calls which return an aggregate indirectly.
144 llvm::Constant *getMessageSendSuperStretFn() const {
145 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
146 return CGM.CreateRuntimeFunction(
147 llvm::FunctionType::get(CGM.VoidTy, params, true),
148 "objc_msgSendSuper_stret");
149 }
150
151 /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
152 /// SEL op, ...)
153 ///
154 /// objc_msgSendSuper_stret with the super2 semantics.
155 llvm::Constant *getMessageSendSuperStretFn2() const {
156 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
157 return CGM.CreateRuntimeFunction(
158 llvm::FunctionType::get(CGM.VoidTy, params, true),
159 "objc_msgSendSuper2_stret");
160 }
161
162 llvm::Constant *getMessageSendSuperFpretFn() const {
163 // There is no objc_msgSendSuper_fpret? How can that work?
164 return getMessageSendSuperFn();
165 }
166
167 llvm::Constant *getMessageSendSuperFpretFn2() const {
168 // There is no objc_msgSendSuper_fpret? How can that work?
169 return getMessageSendSuperFn2();
170 }
171
172 protected:
173 CodeGen::CodeGenModule &CGM;
174
175 public:
176 llvm::IntegerType *ShortTy, *IntTy, *LongTy;
177 llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
178 llvm::Type *IvarOffsetVarTy;
179
180 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
181 llvm::PointerType *ObjectPtrTy;
182
183 /// PtrObjectPtrTy - LLVM type for id *
184 llvm::PointerType *PtrObjectPtrTy;
185
186 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
187 llvm::PointerType *SelectorPtrTy;
188
189 private:
190 /// ProtocolPtrTy - LLVM type for external protocol handles
191 /// (typeof(Protocol))
192 llvm::Type *ExternalProtocolPtrTy;
193
194 public:
195 llvm::Type *getExternalProtocolPtrTy() {
196 if (!ExternalProtocolPtrTy) {
197 // FIXME: It would be nice to unify this with the opaque type, so that the
198 // IR comes out a bit cleaner.
199 CodeGen::CodeGenTypes &Types = CGM.getTypes();
200 ASTContext &Ctx = CGM.getContext();
201 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
202 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
203 }
204
205 return ExternalProtocolPtrTy;
206 }
207
208 // SuperCTy - clang type for struct objc_super.
209 QualType SuperCTy;
210 // SuperPtrCTy - clang type for struct objc_super *.
211 QualType SuperPtrCTy;
212
213 /// SuperTy - LLVM type for struct objc_super.
214 llvm::StructType *SuperTy;
215 /// SuperPtrTy - LLVM type for struct objc_super *.
216 llvm::PointerType *SuperPtrTy;
217
218 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
219 /// in GCC parlance).
220 llvm::StructType *PropertyTy;
221
222 /// PropertyListTy - LLVM type for struct objc_property_list
223 /// (_prop_list_t in GCC parlance).
224 llvm::StructType *PropertyListTy;
225 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
226 llvm::PointerType *PropertyListPtrTy;
227
228 // MethodTy - LLVM type for struct objc_method.
229 llvm::StructType *MethodTy;
230
231 /// CacheTy - LLVM type for struct objc_cache.
232 llvm::Type *CacheTy;
233 /// CachePtrTy - LLVM type for struct objc_cache *.
234 llvm::PointerType *CachePtrTy;
235
236 llvm::Constant *getGetPropertyFn() {
237 CodeGen::CodeGenTypes &Types = CGM.getTypes();
238 ASTContext &Ctx = CGM.getContext();
239 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
240 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
241 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
242 CanQualType Params[] = {
243 IdType, SelType,
244 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy};
245 llvm::FunctionType *FTy =
246 Types.GetFunctionType(
247 Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
248 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
249 }
250
251 llvm::Constant *getSetPropertyFn() {
252 CodeGen::CodeGenTypes &Types = CGM.getTypes();
253 ASTContext &Ctx = CGM.getContext();
254 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
255 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
256 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
257 CanQualType Params[] = {
258 IdType,
259 SelType,
260 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(),
261 IdType,
262 Ctx.BoolTy,
263 Ctx.BoolTy};
264 llvm::FunctionType *FTy =
265 Types.GetFunctionType(
266 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
267 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
268 }
269
270 llvm::Constant *getOptimizedSetPropertyFn(bool atomic, bool copy) {
271 CodeGen::CodeGenTypes &Types = CGM.getTypes();
272 ASTContext &Ctx = CGM.getContext();
273 // void objc_setProperty_atomic(id self, SEL _cmd,
274 // id newValue, ptrdiff_t offset);
275 // void objc_setProperty_nonatomic(id self, SEL _cmd,
276 // id newValue, ptrdiff_t offset);
277 // void objc_setProperty_atomic_copy(id self, SEL _cmd,
278 // id newValue, ptrdiff_t offset);
279 // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
280 // id newValue, ptrdiff_t offset);
281
282 SmallVector<CanQualType,4> Params;
283 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
284 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
285 Params.push_back(IdType);
286 Params.push_back(SelType);
287 Params.push_back(IdType);
288 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
289 llvm::FunctionType *FTy =
290 Types.GetFunctionType(
291 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
292 const char *name;
293 if (atomic && copy)
294 name = "objc_setProperty_atomic_copy";
295 else if (atomic && !copy)
296 name = "objc_setProperty_atomic";
297 else if (!atomic && copy)
298 name = "objc_setProperty_nonatomic_copy";
299 else
300 name = "objc_setProperty_nonatomic";
301
302 return CGM.CreateRuntimeFunction(FTy, name);
303 }
304
305 llvm::Constant *getCopyStructFn() {
306 CodeGen::CodeGenTypes &Types = CGM.getTypes();
307 ASTContext &Ctx = CGM.getContext();
308 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
309 SmallVector<CanQualType,5> Params;
310 Params.push_back(Ctx.VoidPtrTy);
311 Params.push_back(Ctx.VoidPtrTy);
312 Params.push_back(Ctx.getSizeType());
313 Params.push_back(Ctx.BoolTy);
314 Params.push_back(Ctx.BoolTy);
315 llvm::FunctionType *FTy =
316 Types.GetFunctionType(
317 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
318 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
319 }
320
321 /// This routine declares and returns address of:
322 /// void objc_copyCppObjectAtomic(
323 /// void *dest, const void *src,
324 /// void (*copyHelper) (void *dest, const void *source));
325 llvm::Constant *getCppAtomicObjectFunction() {
326 CodeGen::CodeGenTypes &Types = CGM.getTypes();
327 ASTContext &Ctx = CGM.getContext();
328 /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
329 SmallVector<CanQualType,3> Params;
330 Params.push_back(Ctx.VoidPtrTy);
331 Params.push_back(Ctx.VoidPtrTy);
332 Params.push_back(Ctx.VoidPtrTy);
333 llvm::FunctionType *FTy =
334 Types.GetFunctionType(
335 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
336 return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
337 }
338
339 llvm::Constant *getEnumerationMutationFn() {
340 CodeGen::CodeGenTypes &Types = CGM.getTypes();
341 ASTContext &Ctx = CGM.getContext();
342 // void objc_enumerationMutation (id)
343 SmallVector<CanQualType,1> Params;
344 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
345 llvm::FunctionType *FTy =
346 Types.GetFunctionType(
347 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
348 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
349 }
350
351 llvm::Constant *getLookUpClassFn() {
352 CodeGen::CodeGenTypes &Types = CGM.getTypes();
353 ASTContext &Ctx = CGM.getContext();
354 // Class objc_lookUpClass (const char *)
355 SmallVector<CanQualType,1> Params;
356 Params.push_back(
357 Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst())));
358 llvm::FunctionType *FTy =
359 Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration(
360 Ctx.getCanonicalType(Ctx.getObjCClassType()),
361 Params));
362 return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
363 }
364
365 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
366 llvm::Constant *getGcReadWeakFn() {
367 // id objc_read_weak (id *)
368 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
369 llvm::FunctionType *FTy =
370 llvm::FunctionType::get(ObjectPtrTy, args, false);
371 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
372 }
373
374 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
375 llvm::Constant *getGcAssignWeakFn() {
376 // id objc_assign_weak (id, id *)
377 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
378 llvm::FunctionType *FTy =
379 llvm::FunctionType::get(ObjectPtrTy, args, false);
380 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
381 }
382
383 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
384 llvm::Constant *getGcAssignGlobalFn() {
385 // id objc_assign_global(id, id *)
386 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
387 llvm::FunctionType *FTy =
388 llvm::FunctionType::get(ObjectPtrTy, args, false);
389 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
390 }
391
392 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
393 llvm::Constant *getGcAssignThreadLocalFn() {
394 // id objc_assign_threadlocal(id src, id * dest)
395 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
396 llvm::FunctionType *FTy =
397 llvm::FunctionType::get(ObjectPtrTy, args, false);
398 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
399 }
400
401 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
402 llvm::Constant *getGcAssignIvarFn() {
403 // id objc_assign_ivar(id, id *, ptrdiff_t)
404 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
405 CGM.PtrDiffTy };
406 llvm::FunctionType *FTy =
407 llvm::FunctionType::get(ObjectPtrTy, args, false);
408 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
409 }
410
411 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
412 llvm::Constant *GcMemmoveCollectableFn() {
413 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
414 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
415 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
416 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
417 }
418
419 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
420 llvm::Constant *getGcAssignStrongCastFn() {
421 // id objc_assign_strongCast(id, id *)
422 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
423 llvm::FunctionType *FTy =
424 llvm::FunctionType::get(ObjectPtrTy, args, false);
425 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
426 }
427
428 /// ExceptionThrowFn - LLVM objc_exception_throw function.
429 llvm::Constant *getExceptionThrowFn() {
430 // void objc_exception_throw(id)
431 llvm::Type *args[] = { ObjectPtrTy };
432 llvm::FunctionType *FTy =
433 llvm::FunctionType::get(CGM.VoidTy, args, false);
434 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
435 }
436
437 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
438 llvm::Constant *getExceptionRethrowFn() {
439 // void objc_exception_rethrow(void)
440 llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
441 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
442 }
443
444 /// SyncEnterFn - LLVM object_sync_enter function.
445 llvm::Constant *getSyncEnterFn() {
446 // int objc_sync_enter (id)
447 llvm::Type *args[] = { ObjectPtrTy };
448 llvm::FunctionType *FTy =
449 llvm::FunctionType::get(CGM.IntTy, args, false);
450 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
451 }
452
453 /// SyncExitFn - LLVM object_sync_exit function.
454 llvm::Constant *getSyncExitFn() {
455 // int objc_sync_exit (id)
456 llvm::Type *args[] = { ObjectPtrTy };
457 llvm::FunctionType *FTy =
458 llvm::FunctionType::get(CGM.IntTy, args, false);
459 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
460 }
461
462 llvm::Constant *getSendFn(bool IsSuper) const {
463 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
464 }
465
466 llvm::Constant *getSendFn2(bool IsSuper) const {
467 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
468 }
469
470 llvm::Constant *getSendStretFn(bool IsSuper) const {
471 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
472 }
473
474 llvm::Constant *getSendStretFn2(bool IsSuper) const {
475 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
476 }
477
478 llvm::Constant *getSendFpretFn(bool IsSuper) const {
479 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
480 }
481
482 llvm::Constant *getSendFpretFn2(bool IsSuper) const {
483 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
484 }
485
486 llvm::Constant *getSendFp2retFn(bool IsSuper) const {
487 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
488 }
489
490 llvm::Constant *getSendFp2RetFn2(bool IsSuper) const {
491 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
492 }
493
494 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
495 };
496
497 /// ObjCTypesHelper - Helper class that encapsulates lazy
498 /// construction of varies types used during ObjC generation.
499 class ObjCTypesHelper : public ObjCCommonTypesHelper {
500 public:
501 /// SymtabTy - LLVM type for struct objc_symtab.
502 llvm::StructType *SymtabTy;
503 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
504 llvm::PointerType *SymtabPtrTy;
505 /// ModuleTy - LLVM type for struct objc_module.
506 llvm::StructType *ModuleTy;
507
508 /// ProtocolTy - LLVM type for struct objc_protocol.
509 llvm::StructType *ProtocolTy;
510 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
511 llvm::PointerType *ProtocolPtrTy;
512 /// ProtocolExtensionTy - LLVM type for struct
513 /// objc_protocol_extension.
514 llvm::StructType *ProtocolExtensionTy;
515 /// ProtocolExtensionTy - LLVM type for struct
516 /// objc_protocol_extension *.
517 llvm::PointerType *ProtocolExtensionPtrTy;
518 /// MethodDescriptionTy - LLVM type for struct
519 /// objc_method_description.
520 llvm::StructType *MethodDescriptionTy;
521 /// MethodDescriptionListTy - LLVM type for struct
522 /// objc_method_description_list.
523 llvm::StructType *MethodDescriptionListTy;
524 /// MethodDescriptionListPtrTy - LLVM type for struct
525 /// objc_method_description_list *.
526 llvm::PointerType *MethodDescriptionListPtrTy;
527 /// ProtocolListTy - LLVM type for struct objc_property_list.
528 llvm::StructType *ProtocolListTy;
529 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
530 llvm::PointerType *ProtocolListPtrTy;
531 /// CategoryTy - LLVM type for struct objc_category.
532 llvm::StructType *CategoryTy;
533 /// ClassTy - LLVM type for struct objc_class.
534 llvm::StructType *ClassTy;
535 /// ClassPtrTy - LLVM type for struct objc_class *.
536 llvm::PointerType *ClassPtrTy;
537 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
538 llvm::StructType *ClassExtensionTy;
539 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
540 llvm::PointerType *ClassExtensionPtrTy;
541 // IvarTy - LLVM type for struct objc_ivar.
542 llvm::StructType *IvarTy;
543 /// IvarListTy - LLVM type for struct objc_ivar_list.
544 llvm::StructType *IvarListTy;
545 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
546 llvm::PointerType *IvarListPtrTy;
547 /// MethodListTy - LLVM type for struct objc_method_list.
548 llvm::StructType *MethodListTy;
549 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
550 llvm::PointerType *MethodListPtrTy;
551
552 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
553 llvm::StructType *ExceptionDataTy;
554
555 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
556 llvm::Constant *getExceptionTryEnterFn() {
557 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
558 return CGM.CreateRuntimeFunction(
559 llvm::FunctionType::get(CGM.VoidTy, params, false),
560 "objc_exception_try_enter");
561 }
562
563 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
564 llvm::Constant *getExceptionTryExitFn() {
565 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
566 return CGM.CreateRuntimeFunction(
567 llvm::FunctionType::get(CGM.VoidTy, params, false),
568 "objc_exception_try_exit");
569 }
570
571 /// ExceptionExtractFn - LLVM objc_exception_extract function.
572 llvm::Constant *getExceptionExtractFn() {
573 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
574 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
575 params, false),
576 "objc_exception_extract");
577 }
578
579 /// ExceptionMatchFn - LLVM objc_exception_match function.
580 llvm::Constant *getExceptionMatchFn() {
581 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
582 return CGM.CreateRuntimeFunction(
583 llvm::FunctionType::get(CGM.Int32Ty, params, false),
584 "objc_exception_match");
585 }
586
587 /// SetJmpFn - LLVM _setjmp function.
588 llvm::Constant *getSetJmpFn() {
589 // This is specifically the prototype for x86.
590 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
591 return CGM.CreateRuntimeFunction(
592 llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp",
593 llvm::AttributeList::get(CGM.getLLVMContext(),
594 llvm::AttributeList::FunctionIndex,
595 llvm::Attribute::NonLazyBind));
596 }
597
598 public:
599 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
600 };
601
602 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
603 /// modern abi
604 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
605 public:
606 // MethodListnfABITy - LLVM for struct _method_list_t
607 llvm::StructType *MethodListnfABITy;
608
609 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
610 llvm::PointerType *MethodListnfABIPtrTy;
611
612 // ProtocolnfABITy = LLVM for struct _protocol_t
613 llvm::StructType *ProtocolnfABITy;
614
615 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
616 llvm::PointerType *ProtocolnfABIPtrTy;
617
618 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
619 llvm::StructType *ProtocolListnfABITy;
620
621 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
622 llvm::PointerType *ProtocolListnfABIPtrTy;
623
624 // ClassnfABITy - LLVM for struct _class_t
625 llvm::StructType *ClassnfABITy;
626
627 // ClassnfABIPtrTy - LLVM for struct _class_t*
628 llvm::PointerType *ClassnfABIPtrTy;
629
630 // IvarnfABITy - LLVM for struct _ivar_t
631 llvm::StructType *IvarnfABITy;
632
633 // IvarListnfABITy - LLVM for struct _ivar_list_t
634 llvm::StructType *IvarListnfABITy;
635
636 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
637 llvm::PointerType *IvarListnfABIPtrTy;
638
639 // ClassRonfABITy - LLVM for struct _class_ro_t
640 llvm::StructType *ClassRonfABITy;
641
642 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
643 llvm::PointerType *ImpnfABITy;
644
645 // CategorynfABITy - LLVM for struct _category_t
646 llvm::StructType *CategorynfABITy;
647
648 // New types for nonfragile abi messaging.
649
650 // MessageRefTy - LLVM for:
651 // struct _message_ref_t {
652 // IMP messenger;
653 // SEL name;
654 // };
655 llvm::StructType *MessageRefTy;
656 // MessageRefCTy - clang type for struct _message_ref_t
657 QualType MessageRefCTy;
658
659 // MessageRefPtrTy - LLVM for struct _message_ref_t*
660 llvm::Type *MessageRefPtrTy;
661 // MessageRefCPtrTy - clang type for struct _message_ref_t*
662 QualType MessageRefCPtrTy;
663
664 // SuperMessageRefTy - LLVM for:
665 // struct _super_message_ref_t {
666 // SUPER_IMP messenger;
667 // SEL name;
668 // };
669 llvm::StructType *SuperMessageRefTy;
670
671 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
672 llvm::PointerType *SuperMessageRefPtrTy;
673
674 llvm::Constant *getMessageSendFixupFn() {
675 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
676 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
677 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
678 params, true),
679 "objc_msgSend_fixup");
680 }
681
682 llvm::Constant *getMessageSendFpretFixupFn() {
683 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
684 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
685 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
686 params, true),
687 "objc_msgSend_fpret_fixup");
688 }
689
690 llvm::Constant *getMessageSendStretFixupFn() {
691 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
692 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
693 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
694 params, true),
695 "objc_msgSend_stret_fixup");
696 }
697
698 llvm::Constant *getMessageSendSuper2FixupFn() {
699 // id objc_msgSendSuper2_fixup (struct objc_super *,
700 // struct _super_message_ref_t*, ...)
701 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
702 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
703 params, true),
704 "objc_msgSendSuper2_fixup");
705 }
706
707 llvm::Constant *getMessageSendSuper2StretFixupFn() {
708 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
709 // struct _super_message_ref_t*, ...)
710 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
711 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
712 params, true),
713 "objc_msgSendSuper2_stret_fixup");
714 }
715
716 llvm::Constant *getObjCEndCatchFn() {
717 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
718 "objc_end_catch");
719
720 }
721
722 llvm::Constant *getObjCBeginCatchFn() {
723 llvm::Type *params[] = { Int8PtrTy };
724 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
725 params, false),
726 "objc_begin_catch");
727 }
728
729 llvm::StructType *EHTypeTy;
730 llvm::Type *EHTypePtrTy;
731
732 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
733 };
734
735 enum class ObjCLabelType {
736 ClassName,
737 MethodVarName,
738 MethodVarType,
739 PropertyName,
740 };
741
742 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
743 public:
744 class SKIP_SCAN {
745 public:
746 unsigned skip;
747 unsigned scan;
748 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
749 : skip(_skip), scan(_scan) {}
750 };
751
752 /// opcode for captured block variables layout 'instructions'.
753 /// In the following descriptions, 'I' is the value of the immediate field.
754 /// (field following the opcode).
755 ///
756 enum BLOCK_LAYOUT_OPCODE {
757 /// An operator which affects how the following layout should be
758 /// interpreted.
759 /// I == 0: Halt interpretation and treat everything else as
760 /// a non-pointer. Note that this instruction is equal
761 /// to '\0'.
762 /// I != 0: Currently unused.
763 BLOCK_LAYOUT_OPERATOR = 0,
764
765 /// The next I+1 bytes do not contain a value of object pointer type.
766 /// Note that this can leave the stream unaligned, meaning that
767 /// subsequent word-size instructions do not begin at a multiple of
768 /// the pointer size.
769 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
770
771 /// The next I+1 words do not contain a value of object pointer type.
772 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
773 /// when the required skip quantity is a multiple of the pointer size.
774 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
775
776 /// The next I+1 words are __strong pointers to Objective-C
777 /// objects or blocks.
778 BLOCK_LAYOUT_STRONG = 3,
779
780 /// The next I+1 words are pointers to __block variables.
781 BLOCK_LAYOUT_BYREF = 4,
782
783 /// The next I+1 words are __weak pointers to Objective-C
784 /// objects or blocks.
785 BLOCK_LAYOUT_WEAK = 5,
786
787 /// The next I+1 words are __unsafe_unretained pointers to
788 /// Objective-C objects or blocks.
789 BLOCK_LAYOUT_UNRETAINED = 6
790
791 /// The next I+1 words are block or object pointers with some
792 /// as-yet-unspecified ownership semantics. If we add more
793 /// flavors of ownership semantics, values will be taken from
794 /// this range.
795 ///
796 /// This is included so that older tools can at least continue
797 /// processing the layout past such things.
798 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
799
800 /// All other opcodes are reserved. Halt interpretation and
801 /// treat everything else as opaque.
802 };
803
804 class RUN_SKIP {
805 public:
806 enum BLOCK_LAYOUT_OPCODE opcode;
807 CharUnits block_var_bytepos;
808 CharUnits block_var_size;
809 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
810 CharUnits BytePos = CharUnits::Zero(),
811 CharUnits Size = CharUnits::Zero())
812 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
813
814 // Allow sorting based on byte pos.
815 bool operator<(const RUN_SKIP &b) const {
816 return block_var_bytepos < b.block_var_bytepos;
817 }
818 };
819
820 protected:
821 llvm::LLVMContext &VMContext;
822 // FIXME! May not be needing this after all.
823 unsigned ObjCABI;
824
825 // arc/mrr layout of captured block literal variables.
826 SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
827
828 /// LazySymbols - Symbols to generate a lazy reference for. See
829 /// DefinedSymbols and FinishModule().
830 llvm::SetVector<IdentifierInfo*> LazySymbols;
831
832 /// DefinedSymbols - External symbols which are defined by this
833 /// module. The symbols in this list and LazySymbols are used to add
834 /// special linker symbols which ensure that Objective-C modules are
835 /// linked properly.
836 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
837
838 /// ClassNames - uniqued class names.
839 llvm::StringMap<llvm::GlobalVariable*> ClassNames;
840
841 /// MethodVarNames - uniqued method variable names.
842 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
843
844 /// DefinedCategoryNames - list of category names in form Class_Category.
845 llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames;
846
847 /// MethodVarTypes - uniqued method type signatures. We have to use
848 /// a StringMap here because have no other unique reference.
849 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
850
851 /// MethodDefinitions - map of methods which have been defined in
852 /// this translation unit.
853 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
854
855 /// PropertyNames - uniqued method variable names.
856 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
857
858 /// ClassReferences - uniqued class references.
859 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
860
861 /// SelectorReferences - uniqued selector references.
862 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
863
864 /// Protocols - Protocols for which an objc_protocol structure has
865 /// been emitted. Forward declarations are handled by creating an
866 /// empty structure whose initializer is filled in when/if defined.
867 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
868
869 /// DefinedProtocols - Protocols which have actually been
870 /// defined. We should not need this, see FIXME in GenerateProtocol.
871 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
872
873 /// DefinedClasses - List of defined classes.
874 SmallVector<llvm::GlobalValue*, 16> DefinedClasses;
875
876 /// ImplementedClasses - List of @implemented classes.
877 SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses;
878
879 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
880 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
881
882 /// DefinedCategories - List of defined categories.
883 SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
884
885 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
886 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
887
888 /// Cached reference to the class for constant strings. This value has type
889 /// int * but is actually an Obj-C class pointer.
890 llvm::WeakTrackingVH ConstantStringClassRef;
891
892 /// The LLVM type corresponding to NSConstantString.
893 llvm::StructType *NSConstantStringType = nullptr;
894
895 llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;
896
897 /// GetNameForMethod - Return a name for the given method.
898 /// \param[out] NameOut - The return value.
899 void GetNameForMethod(const ObjCMethodDecl *OMD,
900 const ObjCContainerDecl *CD,
901 SmallVectorImpl<char> &NameOut);
902
903 /// GetMethodVarName - Return a unique constant for the given
904 /// selector's name. The return value has type char *.
905 llvm::Constant *GetMethodVarName(Selector Sel);
906 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
907
908 /// GetMethodVarType - Return a unique constant for the given
909 /// method's type encoding string. The return value has type char *.
910
911 // FIXME: This is a horrible name.
912 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
913 bool Extended = false);
914 llvm::Constant *GetMethodVarType(const FieldDecl *D);
915
916 /// GetPropertyName - Return a unique constant for the given
917 /// name. The return value has type char *.
918 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
919
920 // FIXME: This can be dropped once string functions are unified.
921 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
922 const Decl *Container);
923
924 /// GetClassName - Return a unique constant for the given selector's
925 /// runtime name (which may change via use of objc_runtime_name attribute on
926 /// class or protocol definition. The return value has type char *.
927 llvm::Constant *GetClassName(StringRef RuntimeName);
928
929 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
930
931 /// BuildIvarLayout - Builds ivar layout bitmap for the class
932 /// implementation for the __strong or __weak case.
933 ///
934 /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
935 /// are any weak ivars defined directly in the class. Meaningless unless
936 /// building a weak layout. Does not guarantee that the layout will
937 /// actually have any entries, because the ivar might be under-aligned.
938 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
939 CharUnits beginOffset,
940 CharUnits endOffset,
941 bool forStrongLayout,
942 bool hasMRCWeakIvars);
943
944 llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
945 CharUnits beginOffset,
946 CharUnits endOffset) {
947 return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
948 }
949
950 llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
951 CharUnits beginOffset,
952 CharUnits endOffset,
953 bool hasMRCWeakIvars) {
954 return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
955 }
956
957 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
958
959 void UpdateRunSkipBlockVars(bool IsByref,
960 Qualifiers::ObjCLifetime LifeTime,
961 CharUnits FieldOffset,
962 CharUnits FieldSize);
963
964 void BuildRCBlockVarRecordLayout(const RecordType *RT,
965 CharUnits BytePos, bool &HasUnion,
966 bool ByrefLayout=false);
967
968 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
969 const RecordDecl *RD,
970 ArrayRef<const FieldDecl*> RecFields,
971 CharUnits BytePos, bool &HasUnion,
972 bool ByrefLayout);
973
974 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
975
976 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
977
978 /// GetIvarLayoutName - Returns a unique constant for the given
979 /// ivar layout bitmap.
980 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
981 const ObjCCommonTypesHelper &ObjCTypes);
982
983 /// EmitPropertyList - Emit the given property list. The return
984 /// value has type PropertyListPtrTy.
985 llvm::Constant *EmitPropertyList(Twine Name,
986 const Decl *Container,
987 const ObjCContainerDecl *OCD,
988 const ObjCCommonTypesHelper &ObjCTypes,
989 bool IsClassProperty);
990
991 /// EmitProtocolMethodTypes - Generate the array of extended method type
992 /// strings. The return value has type Int8PtrPtrTy.
993 llvm::Constant *EmitProtocolMethodTypes(Twine Name,
994 ArrayRef<llvm::Constant*> MethodTypes,
995 const ObjCCommonTypesHelper &ObjCTypes);
996
997 /// GetProtocolRef - Return a reference to the internal protocol
998 /// description, creating an empty one if it has not been
999 /// defined. The return value has type ProtocolPtrTy.
1000 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1001
1002 /// Return a reference to the given Class using runtime calls rather than
1003 /// by a symbol reference.
1004 llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1005 const ObjCInterfaceDecl *ID,
1006 ObjCCommonTypesHelper &ObjCTypes);
1007
1008 std::string GetSectionName(StringRef Section, StringRef MachOAttributes);
1009
1010 public:
1011 /// CreateMetadataVar - Create a global variable with internal
1012 /// linkage for use by the Objective-C runtime.
1013 ///
1014 /// This is a convenience wrapper which not only creates the
1015 /// variable, but also sets the section and alignment and adds the
1016 /// global to the "llvm.used" list.
1017 ///
1018 /// \param Name - The variable name.
1019 /// \param Init - The variable initializer; this is also used to
1020 /// define the type of the variable.
1021 /// \param Section - The section the variable should go into, or empty.
1022 /// \param Align - The alignment for the variable, or 0.
1023 /// \param AddToUsed - Whether the variable should be added to
1024 /// "llvm.used".
1025 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1026 ConstantStructBuilder &Init,
1027 StringRef Section, CharUnits Align,
1028 bool AddToUsed);
1029 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1030 llvm::Constant *Init,
1031 StringRef Section, CharUnits Align,
1032 bool AddToUsed);
1033
1034 llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
1035 ObjCLabelType LabelType,
1036 bool ForceNonFragileABI = false,
1037 bool NullTerminate = true);
1038
1039 protected:
1040 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1041 ReturnValueSlot Return,
1042 QualType ResultType,
1043 llvm::Value *Sel,
1044 llvm::Value *Arg0,
1045 QualType Arg0Ty,
1046 bool IsSuper,
1047 const CallArgList &CallArgs,
1048 const ObjCMethodDecl *OMD,
1049 const ObjCInterfaceDecl *ClassReceiver,
1050 const ObjCCommonTypesHelper &ObjCTypes);
1051
1052 /// EmitImageInfo - Emit the image info marker used to encode some module
1053 /// level information.
1054 void EmitImageInfo();
1055
1056 public:
1057 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
1058 CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { }
1059
1060 bool isNonFragileABI() const {
1061 return ObjCABI == 2;
1062 }
1063
1064 ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
1065 ConstantAddress GenerateConstantNSString(const StringLiteral *SL);
1066
1067 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1068 const ObjCContainerDecl *CD=nullptr) override;
1069
1070 void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1071
1072 /// GetOrEmitProtocol - Get the protocol object for the given
1073 /// declaration, emitting it if necessary. The return value has type
1074 /// ProtocolPtrTy.
1075 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
1076
1077 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1078 /// object for the given declaration, emitting it if needed. These
1079 /// forward references will be filled in with empty bodies if no
1080 /// definition is seen. The return value has type ProtocolPtrTy.
1081 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1082
1083 virtual llvm::Constant *getNSConstantStringClassRef() = 0;
1084
1085 llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1086 const CGBlockInfo &blockInfo) override;
1087 llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1088 const CGBlockInfo &blockInfo) override;
1089 std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM,
1090 const CGBlockInfo &blockInfo) override;
1091
1092 llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1093 QualType T) override;
1094
1095 private:
1096 void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo);
1097 };
1098
1099 namespace {
1100
1101 enum class MethodListType {
1102 CategoryInstanceMethods,
1103 CategoryClassMethods,
1104 InstanceMethods,
1105 ClassMethods,
1106 ProtocolInstanceMethods,
1107 ProtocolClassMethods,
1108 OptionalProtocolInstanceMethods,
1109 OptionalProtocolClassMethods,
1110 };
1111
1112 /// A convenience class for splitting the methods of a protocol into
1113 /// the four interesting groups.
1114 class ProtocolMethodLists {
1115 public:
1116 enum Kind {
1117 RequiredInstanceMethods,
1118 RequiredClassMethods,
1119 OptionalInstanceMethods,
1120 OptionalClassMethods
1121 };
1122 enum {
1123 NumProtocolMethodLists = 4
1124 };
1125
1126 static MethodListType getMethodListKind(Kind kind) {
1127 switch (kind) {
1128 case RequiredInstanceMethods:
1129 return MethodListType::ProtocolInstanceMethods;
1130 case RequiredClassMethods:
1131 return MethodListType::ProtocolClassMethods;
1132 case OptionalInstanceMethods:
1133 return MethodListType::OptionalProtocolInstanceMethods;
1134 case OptionalClassMethods:
1135 return MethodListType::OptionalProtocolClassMethods;
1136 }
1137 llvm_unreachable("bad kind");
1138 }
1139
1140 SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];
1141
1142 static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
1143 ProtocolMethodLists result;
1144
1145 for (auto MD : PD->methods()) {
1146 size_t index = (2 * size_t(MD->isOptional()))
1147 + (size_t(MD->isClassMethod()));
1148 result.Methods[index].push_back(MD);
1149 }
1150
1151 return result;
1152 }
1153
1154 template <class Self>
1155 SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
1156 // In both ABIs, the method types list is parallel with the
1157 // concatenation of the methods arrays in the following order:
1158 // instance methods
1159 // class methods
1160 // optional instance methods
1161 // optional class methods
1162 SmallVector<llvm::Constant*, 8> result;
1163
1164 // Methods is already in the correct order for both ABIs.
1165 for (auto &list : Methods) {
1166 for (auto MD : list) {
1167 result.push_back(self->GetMethodVarType(MD, true));
1168 }
1169 }
1170
1171 return result;
1172 }
1173
1174 template <class Self>
1175 llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
1176 Kind kind) const {
1177 return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
1178 getMethodListKind(kind), Methods[kind]);
1179 }
1180 };
1181
1182 } // end anonymous namespace
1183
1184 class CGObjCMac : public CGObjCCommonMac {
1185 private:
1186 friend ProtocolMethodLists;
1187
1188 ObjCTypesHelper ObjCTypes;
1189
1190 /// EmitModuleInfo - Another marker encoding module level
1191 /// information.
1192 void EmitModuleInfo();
1193
1194 /// EmitModuleSymols - Emit module symbols, the list of defined
1195 /// classes and categories. The result has type SymtabPtrTy.
1196 llvm::Constant *EmitModuleSymbols();
1197
1198 /// FinishModule - Write out global data structures at the end of
1199 /// processing a translation unit.
1200 void FinishModule();
1201
1202 /// EmitClassExtension - Generate the class extension structure used
1203 /// to store the weak ivar layout and properties. The return value
1204 /// has type ClassExtensionPtrTy.
1205 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1206 CharUnits instanceSize,
1207 bool hasMRCWeakIvars,
1208 bool isMetaclass);
1209
1210 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1211 /// for the given class.
1212 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1213 const ObjCInterfaceDecl *ID);
1214
1215 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1216 IdentifierInfo *II);
1217
1218 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1219
1220 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1221 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1222
1223 /// EmitIvarList - Emit the ivar list for the given
1224 /// implementation. If ForClass is true the list of class ivars
1225 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1226 /// interface ivars will be emitted. The return value has type
1227 /// IvarListPtrTy.
1228 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1229 bool ForClass);
1230
1231 /// EmitMetaClass - Emit a forward reference to the class structure
1232 /// for the metaclass of the given interface. The return value has
1233 /// type ClassPtrTy.
1234 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1235
1236 /// EmitMetaClass - Emit a class structure for the metaclass of the
1237 /// given implementation. The return value has type ClassPtrTy.
1238 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1239 llvm::Constant *Protocols,
1240 ArrayRef<const ObjCMethodDecl *> Methods);
1241
1242 void emitMethodConstant(ConstantArrayBuilder &builder,
1243 const ObjCMethodDecl *MD);
1244
1245 void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
1246 const ObjCMethodDecl *MD);
1247
1248 /// EmitMethodList - Emit the method list for the given
1249 /// implementation. The return value has type MethodListPtrTy.
1250 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1251 ArrayRef<const ObjCMethodDecl *> Methods);
1252
1253 /// GetOrEmitProtocol - Get the protocol object for the given
1254 /// declaration, emitting it if necessary. The return value has type
1255 /// ProtocolPtrTy.
1256 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1257
1258 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1259 /// object for the given declaration, emitting it if needed. These
1260 /// forward references will be filled in with empty bodies if no
1261 /// definition is seen. The return value has type ProtocolPtrTy.
1262 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1263
1264 /// EmitProtocolExtension - Generate the protocol extension
1265 /// structure used to store optional instance and class methods, and
1266 /// protocol properties. The return value has type
1267 /// ProtocolExtensionPtrTy.
1268 llvm::Constant *
1269 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1270 const ProtocolMethodLists &methodLists);
1271
1272 /// EmitProtocolList - Generate the list of referenced
1273 /// protocols. The return value has type ProtocolListPtrTy.
1274 llvm::Constant *EmitProtocolList(Twine Name,
1275 ObjCProtocolDecl::protocol_iterator begin,
1276 ObjCProtocolDecl::protocol_iterator end);
1277
1278 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1279 /// for the given selector.
1280 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1281 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1282
1283 public:
1284 CGObjCMac(CodeGen::CodeGenModule &cgm);
1285
1286 llvm::Constant *getNSConstantStringClassRef() override;
1287
1288 llvm::Function *ModuleInitFunction() override;
1289
1290 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1291 ReturnValueSlot Return,
1292 QualType ResultType,
1293 Selector Sel, llvm::Value *Receiver,
1294 const CallArgList &CallArgs,
1295 const ObjCInterfaceDecl *Class,
1296 const ObjCMethodDecl *Method) override;
1297
1298 CodeGen::RValue
1299 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1300 ReturnValueSlot Return, QualType ResultType,
1301 Selector Sel, const ObjCInterfaceDecl *Class,
1302 bool isCategoryImpl, llvm::Value *Receiver,
1303 bool IsClassMessage, const CallArgList &CallArgs,
1304 const ObjCMethodDecl *Method) override;
1305
1306 llvm::Value *GetClass(CodeGenFunction &CGF,
1307 const ObjCInterfaceDecl *ID) override;
1308
1309 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1310 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1311
1312 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1313 /// untyped one.
1314 llvm::Value *GetSelector(CodeGenFunction &CGF,
1315 const ObjCMethodDecl *Method) override;
1316
1317 llvm::Constant *GetEHType(QualType T) override;
1318
1319 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1320
1321 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1322
1323 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1324
1325 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1326 const ObjCProtocolDecl *PD) override;
1327
1328 llvm::Constant *GetPropertyGetFunction() override;
1329 llvm::Constant *GetPropertySetFunction() override;
1330 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1331 bool copy) override;
1332 llvm::Constant *GetGetStructFunction() override;
1333 llvm::Constant *GetSetStructFunction() override;
1334 llvm::Constant *GetCppAtomicObjectGetFunction() override;
1335 llvm::Constant *GetCppAtomicObjectSetFunction() override;
1336 llvm::Constant *EnumerationMutationFunction() override;
1337
1338 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1339 const ObjCAtTryStmt &S) override;
1340 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1341 const ObjCAtSynchronizedStmt &S) override;
1342 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1343 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1344 bool ClearInsertionPoint=true) override;
1345 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1346 Address AddrWeakObj) override;
1347 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1348 llvm::Value *src, Address dst) override;
1349 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1350 llvm::Value *src, Address dest,
1351 bool threadlocal = false) override;
1352 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1353 llvm::Value *src, Address dest,
1354 llvm::Value *ivarOffset) override;
1355 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1356 llvm::Value *src, Address dest) override;
1357 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1358 Address dest, Address src,
1359 llvm::Value *size) override;
1360
1361 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1362 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1363 unsigned CVRQualifiers) override;
1364 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1365 const ObjCInterfaceDecl *Interface,
1366 const ObjCIvarDecl *Ivar) override;
1367 };
1368
1369 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1370 private:
1371 friend ProtocolMethodLists;
1372 ObjCNonFragileABITypesHelper ObjCTypes;
1373 llvm::GlobalVariable* ObjCEmptyCacheVar;
1374 llvm::Constant* ObjCEmptyVtableVar;
1375
1376 /// SuperClassReferences - uniqued super class references.
1377 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1378
1379 /// MetaClassReferences - uniqued meta class references.
1380 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1381
1382 /// EHTypeReferences - uniqued class ehtype references.
1383 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1384
1385 /// VTableDispatchMethods - List of methods for which we generate
1386 /// vtable-based message dispatch.
1387 llvm::DenseSet<Selector> VTableDispatchMethods;
1388
1389 /// DefinedMetaClasses - List of defined meta-classes.
1390 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1391
1392 /// isVTableDispatchedSelector - Returns true if SEL is a
1393 /// vtable-based selector.
1394 bool isVTableDispatchedSelector(Selector Sel);
1395
1396 /// FinishNonFragileABIModule - Write out global data structures at the end of
1397 /// processing a translation unit.
1398 void FinishNonFragileABIModule();
1399
1400 /// AddModuleClassList - Add the given list of class pointers to the
1401 /// module with the provided symbol and section names.
1402 void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1403 StringRef SymbolName, StringRef SectionName);
1404
1405 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1406 unsigned InstanceStart,
1407 unsigned InstanceSize,
1408 const ObjCImplementationDecl *ID);
1409 llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
1410 bool isMetaclass,
1411 llvm::Constant *IsAGV,
1412 llvm::Constant *SuperClassGV,
1413 llvm::Constant *ClassRoGV,
1414 bool HiddenVisibility);
1415
1416 void emitMethodConstant(ConstantArrayBuilder &builder,
1417 const ObjCMethodDecl *MD,
1418 bool forProtocol);
1419
1420 /// Emit the method list for the given implementation. The return value
1421 /// has type MethodListnfABITy.
1422 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1423 ArrayRef<const ObjCMethodDecl *> Methods);
1424
1425 /// EmitIvarList - Emit the ivar list for the given
1426 /// implementation. If ForClass is true the list of class ivars
1427 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1428 /// interface ivars will be emitted. The return value has type
1429 /// IvarListnfABIPtrTy.
1430 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1431
1432 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1433 const ObjCIvarDecl *Ivar,
1434 unsigned long int offset);
1435
1436 /// GetOrEmitProtocol - Get the protocol object for the given
1437 /// declaration, emitting it if necessary. The return value has type
1438 /// ProtocolPtrTy.
1439 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1440
1441 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1442 /// object for the given declaration, emitting it if needed. These
1443 /// forward references will be filled in with empty bodies if no
1444 /// definition is seen. The return value has type ProtocolPtrTy.
1445 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1446
1447 /// EmitProtocolList - Generate the list of referenced
1448 /// protocols. The return value has type ProtocolListPtrTy.
1449 llvm::Constant *EmitProtocolList(Twine Name,
1450 ObjCProtocolDecl::protocol_iterator begin,
1451 ObjCProtocolDecl::protocol_iterator end);
1452
1453 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1454 ReturnValueSlot Return,
1455 QualType ResultType,
1456 Selector Sel,
1457 llvm::Value *Receiver,
1458 QualType Arg0Ty,
1459 bool IsSuper,
1460 const CallArgList &CallArgs,
1461 const ObjCMethodDecl *Method);
1462
1463 /// GetClassGlobal - Return the global variable for the Objective-C
1464 /// class of the given name.
1465 llvm::Constant *GetClassGlobal(StringRef Name,
1466 ForDefinition_t IsForDefinition,
1467 bool Weak = false, bool DLLImport = false);
1468 llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
1469 bool isMetaclass,
1470 ForDefinition_t isForDefinition);
1471
1472 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1473 /// for the given class reference.
1474 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1475 const ObjCInterfaceDecl *ID);
1476
1477 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1478 IdentifierInfo *II,
1479 const ObjCInterfaceDecl *ID);
1480
1481 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1482
1483 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1484 /// for the given super class reference.
1485 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1486 const ObjCInterfaceDecl *ID);
1487
1488 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1489 /// meta-data
1490 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1491 const ObjCInterfaceDecl *ID, bool Weak);
1492
1493 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1494 /// the given ivar.
1495 ///
1496 llvm::GlobalVariable * ObjCIvarOffsetVariable(
1497 const ObjCInterfaceDecl *ID,
1498 const ObjCIvarDecl *Ivar);
1499
1500 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1501 /// for the given selector.
1502 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1503 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1504
1505 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1506 /// interface. The return value has type EHTypePtrTy.
1507 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1508 ForDefinition_t IsForDefinition);
1509
1510 StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1511
1512 StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1513
1514 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1515 uint32_t &InstanceStart,
1516 uint32_t &InstanceSize);
1517
1518 // Shamelessly stolen from Analysis/CFRefCount.cpp
1519 Selector GetNullarySelector(const char* name) const {
1520 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1521 return CGM.getContext().Selectors.getSelector(0, &II);
1522 }
1523
1524 Selector GetUnarySelector(const char* name) const {
1525 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1526 return CGM.getContext().Selectors.getSelector(1, &II);
1527 }
1528
1529 /// ImplementationIsNonLazy - Check whether the given category or
1530 /// class implementation is "non-lazy".
1531 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1532
1533 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1534 const ObjCIvarDecl *IV) {
1535 // Annotate the load as an invariant load iff inside an instance method
1536 // and ivar belongs to instance method's class and one of its super class.
1537 // This check is needed because the ivar offset is a lazily
1538 // initialised value that may depend on objc_msgSend to perform a fixup on
1539 // the first message dispatch.
1540 //
1541 // An additional opportunity to mark the load as invariant arises when the
1542 // base of the ivar access is a parameter to an Objective C method.
1543 // However, because the parameters are not available in the current
1544 // interface, we cannot perform this check.
1545 if (const ObjCMethodDecl *MD =
1546 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1547 if (MD->isInstanceMethod())
1548 if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1549 return IV->getContainingInterface()->isSuperClassOf(ID);
1550 return false;
1551 }
1552
1553 public:
1554 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1555
1556 llvm::Constant *getNSConstantStringClassRef() override;
1557
1558 llvm::Function *ModuleInitFunction() override;
1559
1560 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1561 ReturnValueSlot Return,
1562 QualType ResultType, Selector Sel,
1563 llvm::Value *Receiver,
1564 const CallArgList &CallArgs,
1565 const ObjCInterfaceDecl *Class,
1566 const ObjCMethodDecl *Method) override;
1567
1568 CodeGen::RValue
1569 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1570 ReturnValueSlot Return, QualType ResultType,
1571 Selector Sel, const ObjCInterfaceDecl *Class,
1572 bool isCategoryImpl, llvm::Value *Receiver,
1573 bool IsClassMessage, const CallArgList &CallArgs,
1574 const ObjCMethodDecl *Method) override;
1575
1576 llvm::Value *GetClass(CodeGenFunction &CGF,
1577 const ObjCInterfaceDecl *ID) override;
1578
1579 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1580 { return EmitSelector(CGF, Sel); }
1581 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1582 { return EmitSelectorAddr(CGF, Sel); }
1583
1584 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1585 /// untyped one.
1586 llvm::Value *GetSelector(CodeGenFunction &CGF,
1587 const ObjCMethodDecl *Method) override
1588 { return EmitSelector(CGF, Method->getSelector()); }
1589
1590 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1591
1592 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1593
1594 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1595
1596 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1597 const ObjCProtocolDecl *PD) override;
1598
1599 llvm::Constant *GetEHType(QualType T) override;
1600
1601 llvm::Constant *GetPropertyGetFunction() override {
1602 return ObjCTypes.getGetPropertyFn();
1603 }
1604 llvm::Constant *GetPropertySetFunction() override {
1605 return ObjCTypes.getSetPropertyFn();
1606 }
1607
1608 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1609 bool copy) override {
1610 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1611 }
1612
1613 llvm::Constant *GetSetStructFunction() override {
1614 return ObjCTypes.getCopyStructFn();
1615 }
1616
1617 llvm::Constant *GetGetStructFunction() override {
1618 return ObjCTypes.getCopyStructFn();
1619 }
1620
1621 llvm::Constant *GetCppAtomicObjectSetFunction() override {
1622 return ObjCTypes.getCppAtomicObjectFunction();
1623 }
1624
1625 llvm::Constant *GetCppAtomicObjectGetFunction() override {
1626 return ObjCTypes.getCppAtomicObjectFunction();
1627 }
1628
1629 llvm::Constant *EnumerationMutationFunction() override {
1630 return ObjCTypes.getEnumerationMutationFn();
1631 }
1632
1633 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1634 const ObjCAtTryStmt &S) override;
1635 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1636 const ObjCAtSynchronizedStmt &S) override;
1637 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1638 bool ClearInsertionPoint=true) override;
1639 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1640 Address AddrWeakObj) override;
1641 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1642 llvm::Value *src, Address edst) override;
1643 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1644 llvm::Value *src, Address dest,
1645 bool threadlocal = false) override;
1646 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1647 llvm::Value *src, Address dest,
1648 llvm::Value *ivarOffset) override;
1649 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1650 llvm::Value *src, Address dest) override;
1651 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1652 Address dest, Address src,
1653 llvm::Value *size) override;
1654 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1655 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1656 unsigned CVRQualifiers) override;
1657 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1658 const ObjCInterfaceDecl *Interface,
1659 const ObjCIvarDecl *Ivar) override;
1660 };
1661
1662 /// A helper class for performing the null-initialization of a return
1663 /// value.
1664 struct NullReturnState {
1665 llvm::BasicBlock *NullBB;
1666 NullReturnState() : NullBB(nullptr) {}
1667
1668 /// Perform a null-check of the given receiver.
1669 void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1670 // Make blocks for the null-receiver and call edges.
1671 NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1672 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1673
1674 // Check for a null receiver and, if there is one, jump to the
1675 // null-receiver block. There's no point in trying to avoid it:
1676 // we're always going to put *something* there, because otherwise
1677 // we shouldn't have done this null-check in the first place.
1678 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1679 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1680
1681 // Otherwise, start performing the call.
1682 CGF.EmitBlock(callBB);
1683 }
1684
1685 /// Complete the null-return operation. It is valid to call this
1686 /// regardless of whether 'init' has been called.
1687 RValue complete(CodeGenFunction &CGF,
1688 ReturnValueSlot returnSlot,
1689 RValue result,
1690 QualType resultType,
1691 const CallArgList &CallArgs,
1692 const ObjCMethodDecl *Method) {
1693 // If we never had to do a null-check, just use the raw result.
1694 if (!NullBB) return result;
1695
1696 // The continuation block. This will be left null if we don't have an
1697 // IP, which can happen if the method we're calling is marked noreturn.
1698 llvm::BasicBlock *contBB = nullptr;
1699
1700 // Finish the call path.
1701 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1702 if (callBB) {
1703 contBB = CGF.createBasicBlock("msgSend.cont");
1704 CGF.Builder.CreateBr(contBB);
1705 }
1706
1707 // Okay, start emitting the null-receiver block.
1708 CGF.EmitBlock(NullBB);
1709
1710 // Release any consumed arguments we've got.
1711 if (Method) {
1712 CallArgList::const_iterator I = CallArgs.begin();
1713 for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1714 e = Method->param_end(); i != e; ++i, ++I) {
1715 const ParmVarDecl *ParamDecl = (*i);
1716 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1717 RValue RV = I->getRValue(CGF);
1718 assert(RV.isScalar() &&
1719 "NullReturnState::complete - arg not on object");
1720 CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1721 }
1722 }
1723 }
1724
1725 // The phi code below assumes that we haven't needed any control flow yet.
1726 assert(CGF.Builder.GetInsertBlock() == NullBB);
1727
1728 // If we've got a void return, just jump to the continuation block.
1729 if (result.isScalar() && resultType->isVoidType()) {
1730 // No jumps required if the message-send was noreturn.
1731 if (contBB) CGF.EmitBlock(contBB);
1732 return result;
1733 }
1734
1735 // If we've got a scalar return, build a phi.
1736 if (result.isScalar()) {
1737 // Derive the null-initialization value.
1738 llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType);
1739
1740 // If no join is necessary, just flow out.
1741 if (!contBB) return RValue::get(null);
1742
1743 // Otherwise, build a phi.
1744 CGF.EmitBlock(contBB);
1745 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1746 phi->addIncoming(result.getScalarVal(), callBB);
1747 phi->addIncoming(null, NullBB);
1748 return RValue::get(phi);
1749 }
1750
1751 // If we've got an aggregate return, null the buffer out.
1752 // FIXME: maybe we should be doing things differently for all the
1753 // cases where the ABI has us returning (1) non-agg values in
1754 // memory or (2) agg values in registers.
1755 if (result.isAggregate()) {
1756 assert(result.isAggregate() && "null init of non-aggregate result?");
1757 if (!returnSlot.isUnused())
1758 CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1759 if (contBB) CGF.EmitBlock(contBB);
1760 return result;
1761 }
1762
1763 // Complex types.
1764 CGF.EmitBlock(contBB);
1765 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1766
1767 // Find the scalar type and its zero value.
1768 llvm::Type *scalarTy = callResult.first->getType();
1769 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1770
1771 // Build phis for both coordinates.
1772 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1773 real->addIncoming(callResult.first, callBB);
1774 real->addIncoming(scalarZero, NullBB);
1775 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1776 imag->addIncoming(callResult.second, callBB);
1777 imag->addIncoming(scalarZero, NullBB);
1778 return RValue::getComplex(real, imag);
1779 }
1780 };
1781
1782 } // end anonymous namespace
1783
1784 /* *** Helper Functions *** */
1785
1786 /// getConstantGEP() - Help routine to construct simple GEPs.
1787 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1788 llvm::GlobalVariable *C, unsigned idx0,
1789 unsigned idx1) {
1790 llvm::Value *Idxs[] = {
1791 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1792 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1793 };
1794 return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1795 }
1796
1797 /// hasObjCExceptionAttribute - Return true if this class or any super
1798 /// class has the __objc_exception__ attribute.
1799 static bool hasObjCExceptionAttribute(ASTContext &Context,
1800 const ObjCInterfaceDecl *OID) {
1801 if (OID->hasAttr<ObjCExceptionAttr>())
1802 return true;
1803 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1804 return hasObjCExceptionAttribute(Context, Super);
1805 return false;
1806 }
1807
1808 /* *** CGObjCMac Public Interface *** */
1809
1810 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1811 ObjCTypes(cgm) {
1812 ObjCABI = 1;
1813 EmitImageInfo();
1814 }
1815
1816 /// GetClass - Return a reference to the class for the given interface
1817 /// decl.
1818 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1819 const ObjCInterfaceDecl *ID) {
1820 return EmitClassRef(CGF, ID);
1821 }
1822
1823 /// GetSelector - Return the pointer to the unique'd string for this selector.
1824 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1825 return EmitSelector(CGF, Sel);
1826 }
1827 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1828 return EmitSelectorAddr(CGF, Sel);
1829 }
1830 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1831 *Method) {
1832 return EmitSelector(CGF, Method->getSelector());
1833 }
1834
1835 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1836 if (T->isObjCIdType() ||
1837 T->isObjCQualifiedIdType()) {
1838 return CGM.GetAddrOfRTTIDescriptor(
1839 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1840 }
1841 if (T->isObjCClassType() ||
1842 T->isObjCQualifiedClassType()) {
1843 return CGM.GetAddrOfRTTIDescriptor(
1844 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1845 }
1846 if (T->isObjCObjectPointerType())
1847 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1848
1849 llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1850 }
1851
1852 /// Generate a constant CFString object.
1853 /*
1854 struct __builtin_CFString {
1855 const int *isa; // point to __CFConstantStringClassReference
1856 int flags;
1857 const char *str;
1858 long length;
1859 };
1860 */
1861
1862 /// or Generate a constant NSString object.
1863 /*
1864 struct __builtin_NSString {
1865 const int *isa; // point to __NSConstantStringClassReference
1866 const char *str;
1867 unsigned int length;
1868 };
1869 */
1870
1871 ConstantAddress
1872 CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1873 return (!CGM.getLangOpts().NoConstantCFStrings
1874 ? CGM.GetAddrOfConstantCFString(SL)
1875 : GenerateConstantNSString(SL));
1876 }
1877
1878 static llvm::StringMapEntry<llvm::GlobalVariable *> &
1879 GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1880 const StringLiteral *Literal, unsigned &StringLength) {
1881 StringRef String = Literal->getString();
1882 StringLength = String.size();
1883 return *Map.insert(std::make_pair(String, nullptr)).first;
1884 }
1885
1886 llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1887 if (llvm::Value *V = ConstantStringClassRef)
1888 return cast<llvm::Constant>(V);
1889
1890 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1891 std::string str =
1892 StringClass.empty() ? "_NSConstantStringClassReference"
1893 : "_" + StringClass + "ClassReference";
1894
1895 llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1896 auto GV = CGM.CreateRuntimeVariable(PTy, str);
1897 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1898 ConstantStringClassRef = V;
1899 return V;
1900 }
1901
1902 llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1903 if (llvm::Value *V = ConstantStringClassRef)
1904 return cast<llvm::Constant>(V);
1905
1906 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1907 std::string str =
1908 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1909 : "OBJC_CLASS_$_" + StringClass;
1910 auto GV = GetClassGlobal(str, NotForDefinition);
1911
1912 // Make sure the result is of the correct type.
1913 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1914
1915 ConstantStringClassRef = V;
1916 return V;
1917 }
1918
1919 ConstantAddress
1920 CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
1921 unsigned StringLength = 0;
1922 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
1923 GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
1924
1925 if (auto *C = Entry.second)
1926 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
1927
1928 // If we don't already have it, get _NSConstantStringClassReference.
1929 llvm::Constant *Class = getNSConstantStringClassRef();
1930
1931 // If we don't already have it, construct the type for a constant NSString.
1932 if (!NSConstantStringType) {
1933 NSConstantStringType =
1934 llvm::StructType::create({
1935 CGM.Int32Ty->getPointerTo(),
1936 CGM.Int8PtrTy,
1937 CGM.IntTy
1938 }, "struct.__builtin_NSString");
1939 }
1940
1941 ConstantInitBuilder Builder(CGM);
1942 auto Fields = Builder.beginStruct(NSConstantStringType);
1943
1944 // Class pointer.
1945 Fields.add(Class);
1946
1947 // String pointer.
1948 llvm::Constant *C =
1949 llvm::ConstantDataArray::getString(VMContext, Entry.first());
1950
1951 llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
1952 bool isConstant = !CGM.getLangOpts().WritableStrings;
1953
1954 auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
1955 Linkage, C, ".str");
1956 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1957 // Don't enforce the target's minimum global alignment, since the only use
1958 // of the string is via this class initializer.
1959 GV->setAlignment(1);
1960 Fields.addBitCast(GV, CGM.Int8PtrTy);
1961
1962 // String length.
1963 Fields.addInt(CGM.IntTy, StringLength);
1964
1965 // The struct.
1966 CharUnits Alignment = CGM.getPointerAlign();
1967 GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
1968 /*constant*/ true,
1969 llvm::GlobalVariable::PrivateLinkage);
1970 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
1971 const char *NSStringNonFragileABISection =
1972 "__DATA,__objc_stringobj,regular,no_dead_strip";
1973 // FIXME. Fix section.
1974 GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
1975 ? NSStringNonFragileABISection
1976 : NSStringSection);
1977 Entry.second = GV;
1978
1979 return ConstantAddress(GV, Alignment);
1980 }
1981
1982 enum {
1983 kCFTaggedObjectID_Integer = (1 << 1) + 1
1984 };
1985
1986 /// Generates a message send where the super is the receiver. This is
1987 /// a message send to self with special delivery semantics indicating
1988 /// which class's method should be called.
1989 CodeGen::RValue
1990 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1991 ReturnValueSlot Return,
1992 QualType ResultType,
1993 Selector Sel,
1994 const ObjCInterfaceDecl *Class,
1995 bool isCategoryImpl,
1996 llvm::Value *Receiver,
1997 bool IsClassMessage,
1998 const CodeGen::CallArgList &CallArgs,
1999 const ObjCMethodDecl *Method) {
2000 // Create and init a super structure; this is a (receiver, class)
2001 // pair we will pass to objc_msgSendSuper.
2002 Address ObjCSuper =
2003 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
2004 "objc_super");
2005 llvm::Value *ReceiverAsObject =
2006 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2007 CGF.Builder.CreateStore(
2008 ReceiverAsObject,
2009 CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
2010
2011 // If this is a class message the metaclass is passed as the target.
2012 llvm::Value *Target;
2013 if (IsClassMessage) {
2014 if (isCategoryImpl) {
2015 // Message sent to 'super' in a class method defined in a category
2016 // implementation requires an odd treatment.
2017 // If we are in a class method, we must retrieve the
2018 // _metaclass_ for the current class, pointed at by
2019 // the class's "isa" pointer. The following assumes that
2020 // isa" is the first ivar in a class (which it must be).
2021 Target = EmitClassRef(CGF, Class->getSuperClass());
2022 Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2023 Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
2024 } else {
2025 llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2026 llvm::Value *SuperPtr =
2027 CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2028 llvm::Value *Super =
2029 CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
2030 Target = Super;
2031 }
2032 } else if (isCategoryImpl)
2033 Target = EmitClassRef(CGF, Class->getSuperClass());
2034 else {
2035 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2036 ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2037 Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
2038 }
2039 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2040 // ObjCTypes types.
2041 llvm::Type *ClassTy =
2042 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
2043 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2044 CGF.Builder.CreateStore(Target,
2045 CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
2046 return EmitMessageSend(CGF, Return, ResultType,
2047 EmitSelector(CGF, Sel),
2048 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
2049 true, CallArgs, Method, Class, ObjCTypes);
2050 }
2051
2052 /// Generate code for a message send expression.
2053 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2054 ReturnValueSlot Return,
2055 QualType ResultType,
2056 Selector Sel,
2057 llvm::Value *Receiver,
2058 const CallArgList &CallArgs,
2059 const ObjCInterfaceDecl *Class,
2060 const ObjCMethodDecl *Method) {
2061 return EmitMessageSend(CGF, Return, ResultType,
2062 EmitSelector(CGF, Sel),
2063 Receiver, CGF.getContext().getObjCIdType(),
2064 false, CallArgs, Method, Class, ObjCTypes);
2065 }
2066
2067 static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
2068 do {
2069 if (ID->isWeakImported())
2070 return true;
2071 } while ((ID = ID->getSuperClass()));
2072
2073 return false;
2074 }
2075
2076 CodeGen::RValue
2077 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2078 ReturnValueSlot Return,
2079 QualType ResultType,
2080 llvm::Value *Sel,
2081 llvm::Value *Arg0,
2082 QualType Arg0Ty,
2083 bool IsSuper,
2084 const CallArgList &CallArgs,
2085 const ObjCMethodDecl *Method,
2086 const ObjCInterfaceDecl *ClassReceiver,
2087 const ObjCCommonTypesHelper &ObjCTypes) {
2088 CallArgList ActualArgs;
2089 if (!IsSuper)
2090 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2091 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2092 ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType());
2093 ActualArgs.addFrom(CallArgs);
2094
2095 // If we're calling a method, use the formal signature.
2096 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2097
2098 if (Method)
2099 assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
2100 CGM.getContext().getCanonicalType(ResultType) &&
2101 "Result type mismatch!");
2102
2103 bool ReceiverCanBeNull = true;
2104
2105 // Super dispatch assumes that self is non-null; even the messenger
2106 // doesn't have a null check internally.
2107 if (IsSuper) {
2108 ReceiverCanBeNull = false;
2109
2110 // If this is a direct dispatch of a class method, check whether the class,
2111 // or anything in its hierarchy, was weak-linked.
2112 } else if (ClassReceiver && Method && Method->isClassMethod()) {
2113 ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
2114
2115 // If we're emitting a method, and self is const (meaning just ARC, for now),
2116 // and the receiver is a load of self, then self is a valid object.
2117 } else if (auto CurMethod =
2118 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
2119 auto Self = CurMethod->getSelfDecl();
2120 if (Self->getType().isConstQualified()) {
2121 if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
2122 llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
2123 if (SelfAddr == LI->getPointerOperand()) {
2124 ReceiverCanBeNull = false;
2125 }
2126 }
2127 }
2128 }
2129
2130 bool RequiresNullCheck = false;
2131
2132 llvm::Constant *Fn = nullptr;
2133 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2134 if (ReceiverCanBeNull) RequiresNullCheck = true;
2135 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
2136 : ObjCTypes.getSendStretFn(IsSuper);
2137 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2138 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2139 : ObjCTypes.getSendFpretFn(IsSuper);
2140 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2141 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2142 : ObjCTypes.getSendFp2retFn(IsSuper);
2143 } else {
2144 // arm64 uses objc_msgSend for stret methods and yet null receiver check
2145 // must be made for it.
2146 if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2147 RequiresNullCheck = true;
2148 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2149 : ObjCTypes.getSendFn(IsSuper);
2150 }
2151
2152 // We don't need to emit a null check to zero out an indirect result if the
2153 // result is ignored.
2154 if (Return.isUnused())
2155 RequiresNullCheck = false;
2156
2157 // Emit a null-check if there's a consumed argument other than the receiver.
2158 if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) {
2159 for (const auto *ParamDecl : Method->parameters()) {
2160 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
2161 RequiresNullCheck = true;
2162 break;
2163 }
2164 }
2165 }
2166
2167 NullReturnState nullReturn;
2168 if (RequiresNullCheck) {
2169 nullReturn.init(CGF, Arg0);
2170 }
2171
2172 llvm::Instruction *CallSite;
2173 Fn = llvm::ConstantExpr::getBitCast(Fn, MSI.MessengerType);
2174 CGCallee Callee = CGCallee::forDirect(Fn);
2175 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2176 &CallSite);
2177
2178 // Mark the call as noreturn if the method is marked noreturn and the
2179 // receiver cannot be null.
2180 if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
2181 llvm::CallSite(CallSite).setDoesNotReturn();
2182 }
2183
2184 return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
2185 RequiresNullCheck ? Method : nullptr);
2186 }
2187
2188 static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT,
2189 bool pointee = false) {
2190 // Note that GC qualification applies recursively to C pointer types
2191 // that aren't otherwise decorated. This is weird, but it's probably
2192 // an intentional workaround to the unreliable placement of GC qualifiers.
2193 if (FQT.isObjCGCStrong())
2194 return Qualifiers::Strong;
2195
2196 if (FQT.isObjCGCWeak())
2197 return Qualifiers::Weak;
2198
2199 if (auto ownership = FQT.getObjCLifetime()) {
2200 // Ownership does not apply recursively to C pointer types.
2201 if (pointee) return Qualifiers::GCNone;
2202 switch (ownership) {
2203 case Qualifiers::OCL_Weak: return Qualifiers::Weak;
2204 case Qualifiers::OCL_Strong: return Qualifiers::Strong;
2205 case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone;
2206 case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
2207 case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
2208 }
2209 llvm_unreachable("bad objc ownership");
2210 }
2211
2212 // Treat unqualified retainable pointers as strong.
2213 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2214 return Qualifiers::Strong;
2215
2216 // Walk into C pointer types, but only in GC.
2217 if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2218 if (const PointerType *PT = FQT->getAs<PointerType>())
2219 return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2220 }
2221
2222 return Qualifiers::GCNone;
2223 }
2224
2225 namespace {
2226 struct IvarInfo {
2227 CharUnits Offset;
2228 uint64_t SizeInWords;
2229 IvarInfo(CharUnits offset, uint64_t sizeInWords)
2230 : Offset(offset), SizeInWords(sizeInWords) {}
2231
2232 // Allow sorting based on byte pos.
2233 bool operator<(const IvarInfo &other) const {
2234 return Offset < other.Offset;
2235 }
2236 };
2237
2238 /// A helper class for building GC layout strings.
2239 class IvarLayoutBuilder {
2240 CodeGenModule &CGM;
2241
2242 /// The start of the layout. Offsets will be relative to this value,
2243 /// and entries less than this value will be silently discarded.
2244 CharUnits InstanceBegin;
2245
2246 /// The end of the layout. Offsets will never exceed this value.
2247 CharUnits InstanceEnd;
2248
2249 /// Whether we're generating the strong layout or the weak layout.
2250 bool ForStrongLayout;
2251
2252 /// Whether the offsets in IvarsInfo might be out-of-order.
2253 bool IsDisordered = false;
2254
2255 llvm::SmallVector<IvarInfo, 8> IvarsInfo;
2256
2257 public:
2258 IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2259 CharUnits instanceEnd, bool forStrongLayout)
2260 : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2261 ForStrongLayout(forStrongLayout) {
2262 }
2263
2264 void visitRecord(const RecordType *RT, CharUnits offset);
2265
2266 template <class Iterator, class GetOffsetFn>
2267 void visitAggregate(Iterator begin, Iterator end,
2268 CharUnits aggrOffset,
2269 const GetOffsetFn &getOffset);
2270
2271 void visitField(const FieldDecl *field, CharUnits offset);
2272
2273 /// Add the layout of a block implementation.
2274 void visitBlock(const CGBlockInfo &blockInfo);
2275
2276 /// Is there any information for an interesting bitmap?
2277 bool hasBitmapData() const { return !IvarsInfo.empty(); }
2278
2279 llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2280 llvm::SmallVectorImpl<unsigned char> &buffer);
2281
2282 static void dump(ArrayRef<unsigned char> buffer) {
2283 const unsigned char *s = buffer.data();
2284 for (unsigned i = 0, e = buffer.size(); i < e; i++)
2285 if (!(s[i] & 0xf0))
2286 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2287 else
2288 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2289 printf("\n");
2290 }
2291 };
2292 } // end anonymous namespace
2293
2294 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2295 const CGBlockInfo &blockInfo) {
2296
2297 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2298 if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2299 return nullPtr;
2300
2301 IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2302 /*for strong layout*/ true);
2303
2304 builder.visitBlock(blockInfo);
2305
2306 if (!builder.hasBitmapData())
2307 return nullPtr;
2308
2309 llvm::SmallVector<unsigned char, 32> buffer;
2310 llvm::Constant *C = builder.buildBitmap(*this, buffer);
2311 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2312 printf("\n block variable layout for block: ");
2313 builder.dump(buffer);
2314 }
2315
2316 return C;
2317 }
2318
2319 void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2320 // __isa is the first field in block descriptor and must assume by runtime's
2321 // convention that it is GC'able.
2322 IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2323
2324 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2325
2326 // Ignore the optional 'this' capture: C++ objects are not assumed
2327 // to be GC'ed.
2328
2329 CharUnits lastFieldOffset;
2330
2331 // Walk the captured variables.
2332 for (const auto &CI : blockDecl->captures()) {
2333 const VarDecl *variable = CI.getVariable();
2334 QualType type = variable->getType();
2335
2336 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2337
2338 // Ignore constant captures.
2339 if (capture.isConstant()) continue;
2340
2341 CharUnits fieldOffset = capture.getOffset();
2342
2343 // Block fields are not necessarily ordered; if we detect that we're
2344 // adding them out-of-order, make sure we sort later.
2345 if (fieldOffset < lastFieldOffset)
2346 IsDisordered = true;
2347 lastFieldOffset = fieldOffset;
2348
2349 // __block variables are passed by their descriptor address.
2350 if (CI.isByRef()) {
2351 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2352 continue;
2353 }
2354
2355 assert(!type->isArrayType() && "array variable should not be caught");
2356 if (const RecordType *record = type->getAs<RecordType>()) {
2357 visitRecord(record, fieldOffset);
2358 continue;
2359 }
2360
2361 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
2362
2363 if (GCAttr == Qualifiers::Strong) {
2364 assert(CGM.getContext().getTypeSize(type)
2365 == CGM.getTarget().getPointerWidth(0));
2366 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2367 }
2368 }
2369 }
2370
2371 /// getBlockCaptureLifetime - This routine returns life time of the captured
2372 /// block variable for the purpose of block layout meta-data generation. FQT is
2373 /// the type of the variable captured in the block.
2374 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2375 bool ByrefLayout) {
2376 // If it has an ownership qualifier, we're done.
2377 if (auto lifetime = FQT.getObjCLifetime())
2378 return lifetime;
2379
2380 // If it doesn't, and this is ARC, it has no ownership.
2381 if (CGM.getLangOpts().ObjCAutoRefCount)
2382 return Qualifiers::OCL_None;
2383
2384 // In MRC, retainable pointers are owned by non-__block variables.
2385 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2386 return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;
2387
2388 return Qualifiers::OCL_None;
2389 }
2390
2391 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2392 Qualifiers::ObjCLifetime LifeTime,
2393 CharUnits FieldOffset,
2394 CharUnits FieldSize) {
2395 // __block variables are passed by their descriptor address.
2396 if (IsByref)
2397 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2398 FieldSize));
2399 else if (LifeTime == Qualifiers::OCL_Strong)
2400 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2401 FieldSize));
2402 else if (LifeTime == Qualifiers::OCL_Weak)
2403 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2404 FieldSize));
2405 else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2406 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2407 FieldSize));
2408 else
2409 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2410 FieldOffset,
2411 FieldSize));
2412 }
2413
2414 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2415 const RecordDecl *RD,
2416 ArrayRef<const FieldDecl*> RecFields,
2417 CharUnits BytePos, bool &HasUnion,
2418 bool ByrefLayout) {
2419 bool IsUnion = (RD && RD->isUnion());
2420 CharUnits MaxUnionSize = CharUnits::Zero();
2421 const FieldDecl *MaxField = nullptr;
2422 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2423 CharUnits MaxFieldOffset = CharUnits::Zero();
2424 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2425
2426 if (RecFields.empty())
2427 return;
2428 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2429
2430 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2431 const FieldDecl *Field = RecFields[i];
2432 // Note that 'i' here is actually the field index inside RD of Field,
2433 // although this dependency is hidden.
2434 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2435 CharUnits FieldOffset =
2436 CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2437
2438 // Skip over unnamed or bitfields
2439 if (!Field->getIdentifier() || Field->isBitField()) {
2440 LastFieldBitfieldOrUnnamed = Field;
2441 LastBitfieldOrUnnamedOffset = FieldOffset;
2442 continue;
2443 }
2444
2445 LastFieldBitfieldOrUnnamed = nullptr;
2446 QualType FQT = Field->getType();
2447 if (FQT->isRecordType() || FQT->isUnionType()) {
2448 if (FQT->isUnionType())
2449 HasUnion = true;
2450
2451 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2452 BytePos + FieldOffset, HasUnion);
2453 continue;
2454 }
2455
2456 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2457 const ConstantArrayType *CArray =
2458 dyn_cast_or_null<ConstantArrayType>(Array);
2459 uint64_t ElCount = CArray->getSize().getZExtValue();
2460 assert(CArray && "only array with known element size is supported");
2461 FQT = CArray->getElementType();
2462 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2463 const ConstantArrayType *CArray =
2464 dyn_cast_or_null<ConstantArrayType>(Array);
2465 ElCount *= CArray->getSize().getZExtValue();
2466 FQT = CArray->getElementType();
2467 }
2468 if (FQT->isRecordType() && ElCount) {
2469 int OldIndex = RunSkipBlockVars.size() - 1;
2470 const RecordType *RT = FQT->getAs<RecordType>();
2471 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2472 HasUnion);
2473
2474 // Replicate layout information for each array element. Note that
2475 // one element is already done.
2476 uint64_t ElIx = 1;
2477 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2478 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2479 for (int i = OldIndex+1; i <= FirstIndex; ++i)
2480 RunSkipBlockVars.push_back(
2481 RUN_SKIP(RunSkipBlockVars[i].opcode,
2482 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2483 RunSkipBlockVars[i].block_var_size));
2484 }
2485 continue;
2486 }
2487 }
2488 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2489 if (IsUnion) {
2490 CharUnits UnionIvarSize = FieldSize;
2491 if (UnionIvarSize > MaxUnionSize) {
2492 MaxUnionSize = UnionIvarSize;
2493 MaxField = Field;
2494 MaxFieldOffset = FieldOffset;
2495 }
2496 } else {
2497 UpdateRunSkipBlockVars(false,
2498 getBlockCaptureLifetime(FQT, ByrefLayout),
2499 BytePos + FieldOffset,
2500 FieldSize);
2501 }
2502 }
2503
2504 if (LastFieldBitfieldOrUnnamed) {
2505 if (LastFieldBitfieldOrUnnamed->isBitField()) {
2506 // Last field was a bitfield. Must update the info.
2507 uint64_t BitFieldSize
2508 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2509 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2510 ((BitFieldSize % ByteSizeInBits) != 0);
2511 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2512 Size += LastBitfieldOrUnnamedOffset;
2513 UpdateRunSkipBlockVars(false,
2514 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2515 ByrefLayout),
2516 BytePos + LastBitfieldOrUnnamedOffset,
2517 Size);
2518 } else {
2519 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2520 // Last field was unnamed. Must update skip info.
2521 CharUnits FieldSize
2522 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2523 UpdateRunSkipBlockVars(false,
2524 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2525 ByrefLayout),
2526 BytePos + LastBitfieldOrUnnamedOffset,
2527 FieldSize);
2528 }
2529 }
2530
2531 if (MaxField)
2532 UpdateRunSkipBlockVars(false,
2533 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2534 BytePos + MaxFieldOffset,
2535 MaxUnionSize);
2536 }
2537
2538 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2539 CharUnits BytePos,
2540 bool &HasUnion,
2541 bool ByrefLayout) {
2542 const RecordDecl *RD = RT->getDecl();
2543 SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2544 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2545 const llvm::StructLayout *RecLayout =
2546 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2547
2548 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2549 }
2550
2551 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2552 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2553 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2554 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2555 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2556 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2557 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2558 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2559 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2560 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2561 SmallVectorImpl<unsigned char> &Layout) {
2562 uint64_t Result = 0;
2563 if (Layout.size() <= 3) {
2564 unsigned size = Layout.size();
2565 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2566 unsigned char inst;
2567 enum BLOCK_LAYOUT_OPCODE opcode ;
2568 switch (size) {
2569 case 3:
2570 inst = Layout[0];
2571 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2572 if (opcode == BLOCK_LAYOUT_STRONG)
2573 strong_word_count = (inst & 0xF)+1;
2574 else
2575 return 0;
2576 inst = Layout[1];
2577 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2578 if (opcode == BLOCK_LAYOUT_BYREF)
2579 byref_word_count = (inst & 0xF)+1;
2580 else
2581 return 0;
2582 inst = Layout[2];
2583 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2584 if (opcode == BLOCK_LAYOUT_WEAK)
2585 weak_word_count = (inst & 0xF)+1;
2586 else
2587 return 0;
2588 break;
2589
2590 case 2:
2591 inst = Layout[0];
2592 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2593 if (opcode == BLOCK_LAYOUT_STRONG) {
2594 strong_word_count = (inst & 0xF)+1;
2595 inst = Layout[1];
2596 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2597 if (opcode == BLOCK_LAYOUT_BYREF)
2598 byref_word_count = (inst & 0xF)+1;
2599 else if (opcode == BLOCK_LAYOUT_WEAK)
2600 weak_word_count = (inst & 0xF)+1;
2601 else
2602 return 0;
2603 }
2604 else if (opcode == BLOCK_LAYOUT_BYREF) {
2605 byref_word_count = (inst & 0xF)+1;
2606 inst = Layout[1];
2607 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2608 if (opcode == BLOCK_LAYOUT_WEAK)
2609 weak_word_count = (inst & 0xF)+1;
2610 else
2611 return 0;
2612 }
2613 else
2614 return 0;
2615 break;
2616
2617 case 1:
2618 inst = Layout[0];
2619 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2620 if (opcode == BLOCK_LAYOUT_STRONG)
2621 strong_word_count = (inst & 0xF)+1;
2622 else if (opcode == BLOCK_LAYOUT_BYREF)
2623 byref_word_count = (inst & 0xF)+1;
2624 else if (opcode == BLOCK_LAYOUT_WEAK)
2625 weak_word_count = (inst & 0xF)+1;
2626 else
2627 return 0;
2628 break;
2629
2630 default:
2631 return 0;
2632 }
2633
2634 // Cannot inline when any of the word counts is 15. Because this is one less
2635 // than the actual work count (so 15 means 16 actual word counts),
2636 // and we can only display 0 thru 15 word counts.
2637 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2638 return 0;
2639
2640 unsigned count =
2641 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2642
2643 if (size == count) {
2644 if (strong_word_count)
2645 Result = strong_word_count;
2646 Result <<= 4;
2647 if (byref_word_count)
2648 Result += byref_word_count;
2649 Result <<= 4;
2650 if (weak_word_count)
2651 Result += weak_word_count;
2652 }
2653 }
2654 return Result;
2655 }
2656
2657 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2658 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2659 if (RunSkipBlockVars.empty())
2660 return nullPtr;
2661 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2662 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2663 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2664
2665 // Sort on byte position; captures might not be allocated in order,
2666 // and unions can do funny things.
2667 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2668 SmallVector<unsigned char, 16> Layout;
2669
2670 unsigned size = RunSkipBlockVars.size();
2671 for (unsigned i = 0; i < size; i++) {
2672 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2673 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2674 CharUnits end_byte_pos = start_byte_pos;
2675 unsigned j = i+1;
2676 while (j < size) {
2677 if (opcode == RunSkipBlockVars[j].opcode) {
2678 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2679 i++;
2680 }
2681 else
2682 break;
2683 }
2684 CharUnits size_in_bytes =
2685 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2686 if (j < size) {
2687 CharUnits gap =
2688 RunSkipBlockVars[j].block_var_bytepos -
2689 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2690 size_in_bytes += gap;
2691 }
2692 CharUnits residue_in_bytes = CharUnits::Zero();
2693 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2694 residue_in_bytes = size_in_bytes % WordSizeInBytes;
2695 size_in_bytes -= residue_in_bytes;
2696 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2697 }
2698
2699 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2700 while (size_in_words >= 16) {
2701 // Note that value in imm. is one less that the actual
2702 // value. So, 0xf means 16 words follow!
2703 unsigned char inst = (opcode << 4) | 0xf;
2704 Layout.push_back(inst);
2705 size_in_words -= 16;
2706 }
2707 if (size_in_words > 0) {
2708 // Note that value in imm. is one less that the actual
2709 // value. So, we subtract 1 away!
2710 unsigned char inst = (opcode << 4) | (size_in_words-1);
2711 Layout.push_back(inst);
2712 }
2713 if (residue_in_bytes > CharUnits::Zero()) {
2714 unsigned char inst =
2715 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2716 Layout.push_back(inst);
2717 }
2718 }
2719
2720 while (!Layout.empty()) {
2721 unsigned char inst = Layout.back();
2722 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2723 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2724 Layout.pop_back();
2725 else
2726 break;
2727 }
2728
2729 uint64_t Result = InlineLayoutInstruction(Layout);
2730 if (Result != 0) {
2731 // Block variable layout instruction has been inlined.
2732 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2733 if (ComputeByrefLayout)
2734 printf("\n Inline BYREF variable layout: ");
2735 else
2736 printf("\n Inline block variable layout: ");
2737 printf("0x0%" PRIx64 "", Result);
2738 if (auto numStrong = (Result & 0xF00) >> 8)
2739 printf(", BL_STRONG:%d", (int) numStrong);
2740 if (auto numByref = (Result & 0x0F0) >> 4)
2741 printf(", BL_BYREF:%d", (int) numByref);
2742 if (auto numWeak = (Result & 0x00F) >> 0)
2743 printf(", BL_WEAK:%d", (int) numWeak);
2744 printf(", BL_OPERATOR:0\n");
2745 }
2746 return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2747 }
2748
2749 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2750 Layout.push_back(inst);
2751 std::string BitMap;
2752 for (unsigned i = 0, e = Layout.size(); i != e; i++)
2753 BitMap += Layout[i];
2754
2755 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2756 if (ComputeByrefLayout)
2757 printf("\n Byref variable layout: ");
2758 else
2759 printf("\n Block variable layout: ");
2760 for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2761 unsigned char inst = BitMap[i];
2762 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2763 unsigned delta = 1;
2764 switch (opcode) {
2765 case BLOCK_LAYOUT_OPERATOR:
2766 printf("BL_OPERATOR:");
2767 delta = 0;
2768 break;
2769 case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2770 printf("BL_NON_OBJECT_BYTES:");
2771 break;
2772 case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2773 printf("BL_NON_OBJECT_WORD:");
2774 break;
2775 case BLOCK_LAYOUT_STRONG:
2776 printf("BL_STRONG:");
2777 break;
2778 case BLOCK_LAYOUT_BYREF:
2779 printf("BL_BYREF:");
2780 break;
2781 case BLOCK_LAYOUT_WEAK:
2782 printf("BL_WEAK:");
2783 break;
2784 case BLOCK_LAYOUT_UNRETAINED:
2785 printf("BL_UNRETAINED:");
2786 break;
2787 }
2788 // Actual value of word count is one more that what is in the imm.
2789 // field of the instruction
2790 printf("%d", (inst & 0xf) + delta);
2791 if (i < e-1)
2792 printf(", ");
2793 else
2794 printf("\n");
2795 }
2796 }
2797
2798 auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2799 /*ForceNonFragileABI=*/true,
2800 /*NullTerminate=*/false);
2801 return getConstantGEP(VMContext, Entry, 0, 0);
2802 }
2803
2804 static std::string getBlockLayoutInfoString(
2805 const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
2806 bool HasCopyDisposeHelpers) {
2807 std::string Str;
2808 for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
2809 if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
2810 // Copy/dispose helpers don't have any information about
2811 // __unsafe_unretained captures, so unconditionally concatenate a string.
2812 Str += "u";
2813 } else if (HasCopyDisposeHelpers) {
2814 // Information about __strong, __weak, or byref captures has already been
2815 // encoded into the names of the copy/dispose helpers. We have to add a
2816 // string here only when the copy/dispose helpers aren't generated (which
2817 // happens when the block is non-escaping).
2818 continue;
2819 } else {
2820 switch (R.opcode) {
2821 case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
2822 Str += "s";
2823 break;
2824 case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
2825 Str += "r";
2826 break;
2827 case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
2828 Str += "w";
2829 break;
2830 default:
2831 continue;
2832 }
2833 }
2834 Str += llvm::to_string(R.block_var_bytepos.getQuantity());
2835 Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
2836 }
2837 return Str;
2838 }
2839
2840 void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
2841 const CGBlockInfo &blockInfo) {
2842 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2843
2844 RunSkipBlockVars.clear();
2845 bool hasUnion = false;
2846
2847 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2848 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2849 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2850
2851 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2852
2853 // Calculate the basic layout of the block structure.
2854 const llvm::StructLayout *layout =
2855 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2856
2857 // Ignore the optional 'this' capture: C++ objects are not assumed
2858 // to be GC'ed.
2859 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2860 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2861 blockInfo.BlockHeaderForcedGapOffset,
2862 blockInfo.BlockHeaderForcedGapSize);
2863 // Walk the captured variables.
2864 for (const auto &CI : blockDecl->captures()) {
2865 const VarDecl *variable = CI.getVariable();
2866 QualType type = variable->getType();
2867
2868 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2869
2870 // Ignore constant captures.
2871 if (capture.isConstant()) continue;
2872
2873 CharUnits fieldOffset =
2874 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2875
2876 assert(!type->isArrayType() && "array variable should not be caught");
2877 if (!CI.isByRef())
2878 if (const RecordType *record = type->getAs<RecordType>()) {
2879 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2880 continue;
2881 }
2882 CharUnits fieldSize;
2883 if (CI.isByRef())
2884 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2885 else
2886 fieldSize = CGM.getContext().getTypeSizeInChars(type);
2887 UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2888 fieldOffset, fieldSize);
2889 }
2890 }
2891
2892 llvm::Constant *
2893 CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2894 const CGBlockInfo &blockInfo) {
2895 fillRunSkipBlockVars(CGM, blockInfo);
2896 return getBitmapBlockLayout(false);
2897 }
2898
2899 std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
2900 const CGBlockInfo &blockInfo) {
2901 fillRunSkipBlockVars(CGM, blockInfo);
2902 return getBlockLayoutInfoString(RunSkipBlockVars,
2903 blockInfo.needsCopyDisposeHelpers());
2904 }
2905
2906 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2907 QualType T) {
2908 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2909 assert(!T->isArrayType() && "__block array variable should not be caught");
2910 CharUnits fieldOffset;
2911 RunSkipBlockVars.clear();
2912 bool hasUnion = false;
2913 if (const RecordType *record = T->getAs<RecordType>()) {
2914 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2915 llvm::Constant *Result = getBitmapBlockLayout(true);
2916 if (isa<llvm::ConstantInt>(Result))
2917 Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
2918 return Result;
2919 }
2920 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2921 return nullPtr;
2922 }
2923
2924 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2925 const ObjCProtocolDecl *PD) {
2926 // FIXME: I don't understand why gcc generates this, or where it is
2927 // resolved. Investigate. Its also wasteful to look this up over and over.
2928 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2929
2930 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2931 ObjCTypes.getExternalProtocolPtrTy());
2932 }
2933
2934 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2935 // FIXME: We shouldn't need this, the protocol decl should contain enough
2936 // information to tell us whether this was a declaration or a definition.
2937 DefinedProtocols.insert(PD->getIdentifier());
2938
2939 // If we have generated a forward reference to this protocol, emit
2940 // it now. Otherwise do nothing, the protocol objects are lazily
2941 // emitted.
2942 if (Protocols.count(PD->getIdentifier()))
2943 GetOrEmitProtocol(PD);
2944 }
2945
2946 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
2947 if (DefinedProtocols.count(PD->getIdentifier()))
2948 return GetOrEmitProtocol(PD);
2949
2950 return GetOrEmitProtocolRef(PD);
2951 }
2952
2953 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
2954 CodeGenFunction &CGF,
2955 const ObjCInterfaceDecl *ID,
2956 ObjCCommonTypesHelper &ObjCTypes) {
2957 llvm::Constant *lookUpClassFn = ObjCTypes.getLookUpClassFn();
2958
2959 llvm::Value *className =
2960 CGF.CGM.GetAddrOfConstantCString(ID->getObjCRuntimeNameAsString())
2961 .getPointer();
2962 ASTContext &ctx = CGF.CGM.getContext();
2963 className =
2964 CGF.Builder.CreateBitCast(className,
2965 CGF.ConvertType(
2966 ctx.getPointerType(ctx.CharTy.withConst())));
2967 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
2968 call->setDoesNotThrow();
2969 return call;
2970 }
2971
2972 /*
2973 // Objective-C 1.0 extensions
2974 struct _objc_protocol {
2975 struct _objc_protocol_extension *isa;
2976 char *protocol_name;
2977 struct _objc_protocol_list *protocol_list;
2978 struct _objc__method_prototype_list *instance_methods;
2979 struct _objc__method_prototype_list *class_methods
2980 };
2981
2982 See EmitProtocolExtension().
2983 */
2984 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
2985 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
2986
2987 // Early exit if a defining object has already been generated.
2988 if (Entry && Entry->hasInitializer())
2989 return Entry;
2990
2991 // Use the protocol definition, if there is one.
2992 if (const ObjCProtocolDecl *Def = PD->getDefinition())
2993 PD = Def;
2994
2995 // FIXME: I don't understand why gcc generates this, or where it is
2996 // resolved. Investigate. Its also wasteful to look this up over and over.
2997 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2998
2999 // Construct method lists.
3000 auto methodLists = ProtocolMethodLists::get(PD);
3001
3002 ConstantInitBuilder builder(CGM);
3003 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3004 values.add(EmitProtocolExtension(PD, methodLists));
3005 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3006 values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3007 PD->protocol_begin(), PD->protocol_end()));
3008 values.add(methodLists.emitMethodList(this, PD,
3009 ProtocolMethodLists::RequiredInstanceMethods));
3010 values.add(methodLists.emitMethodList(this, PD,
3011 ProtocolMethodLists::RequiredClassMethods));
3012
3013 if (Entry) {
3014 // Already created, update the initializer.
3015 assert(Entry->hasPrivateLinkage());
3016 values.finishAndSetAsInitializer(Entry);
3017 } else {
3018 Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3019 CGM.getPointerAlign(),
3020 /*constant*/ false,
3021 llvm::GlobalValue::PrivateLinkage);
3022 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3023
3024 Protocols[PD->getIdentifier()] = Entry;
3025 }
3026 CGM.addCompilerUsedGlobal(Entry);
3027
3028 return Entry;
3029 }
3030
3031 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3032 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3033
3034 if (!Entry) {
3035 // We use the initializer as a marker of whether this is a forward
3036 // reference or not. At module finalization we add the empty
3037 // contents for protocols which were referenced but never defined.
3038 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3039 false, llvm::GlobalValue::PrivateLinkage,
3040 nullptr, "OBJC_PROTOCOL_" + PD->getName());
3041 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3042 // FIXME: Is this necessary? Why only for protocol?
3043 Entry->setAlignment(4);
3044 }
3045
3046 return Entry;
3047 }
3048
3049 /*
3050 struct _objc_protocol_extension {
3051 uint32_t size;
3052 struct objc_method_description_list *optional_instance_methods;
3053 struct objc_method_description_list *optional_class_methods;
3054 struct objc_property_list *instance_properties;
3055 const char ** extendedMethodTypes;
3056 struct objc_property_list *class_properties;
3057 };
3058 */
3059 llvm::Constant *
3060 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3061 const ProtocolMethodLists &methodLists) {
3062 auto optInstanceMethods =
3063 methodLists.emitMethodList(this, PD,
3064 ProtocolMethodLists::OptionalInstanceMethods);
3065 auto optClassMethods =
3066 methodLists.emitMethodList(this, PD,
3067 ProtocolMethodLists::OptionalClassMethods);
3068
3069 auto extendedMethodTypes =
3070 EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3071 methodLists.emitExtendedTypesArray(this),
3072 ObjCTypes);
3073
3074 auto instanceProperties =
3075 EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3076 ObjCTypes, false);
3077 auto classProperties =
3078 EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3079 PD, ObjCTypes, true);
3080
3081 // Return null if no extension bits are used.
3082 if (optInstanceMethods->isNullValue() &&
3083 optClassMethods->isNullValue() &&
3084 extendedMethodTypes->isNullValue() &&
3085 instanceProperties->isNullValue() &&
3086 classProperties->isNullValue()) {
3087 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3088 }
3089
3090 uint64_t size =
3091 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3092
3093 ConstantInitBuilder builder(CGM);
3094 auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3095 values.addInt(ObjCTypes.IntTy, size);
3096 values.add(optInstanceMethods);
3097 values.add(optClassMethods);
3098 values.add(instanceProperties);
3099 values.add(extendedMethodTypes);
3100 values.add(classProperties);
3101
3102 // No special section, but goes in llvm.used
3103 return CreateMetadataVar("\01l_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3104 StringRef(), CGM.getPointerAlign(), true);
3105 }
3106
3107 /*
3108 struct objc_protocol_list {
3109 struct objc_protocol_list *next;
3110 long count;
3111 Protocol *list[];
3112 };
3113 */
3114 llvm::Constant *
3115 CGObjCMac::EmitProtocolList(Twine name,
3116 ObjCProtocolDecl::protocol_iterator begin,
3117 ObjCProtocolDecl::protocol_iterator end) {
3118 // Just return null for empty protocol lists
3119 if (begin == end)
3120 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3121
3122 ConstantInitBuilder builder(CGM);
3123 auto values = builder.beginStruct();
3124
3125 // This field is only used by the runtime.
3126 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3127
3128 // Reserve a slot for the count.
3129 auto countSlot = values.addPlaceholder();
3130
3131 auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3132 for (; begin != end; ++begin) {
3133 refsArray.add(GetProtocolRef(*begin));
3134 }
3135 auto count = refsArray.size();
3136
3137 // This list is null terminated.
3138 refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3139
3140 refsArray.finishAndAddTo(values);
3141 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3142
3143 StringRef section;
3144 if (CGM.getTriple().isOSBinFormatMachO())
3145 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3146
3147 llvm::GlobalVariable *GV =
3148 CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3149 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3150 }
3151
3152 static void
3153 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3154 SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3155 const ObjCProtocolDecl *Proto,
3156 bool IsClassProperty) {
3157 for (const auto *P : Proto->protocols())
3158 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3159
3160 for (const auto *PD : Proto->properties()) {
3161 if (IsClassProperty != PD->isClassProperty())
3162 continue;
3163 if (!PropertySet.insert(PD->getIdentifier()).second)
3164 continue;
3165 Properties.push_back(PD);
3166 }
3167 }
3168
3169 /*
3170 struct _objc_property {
3171 const char * const name;
3172 const char * const attributes;
3173 };
3174
3175 struct _objc_property_list {
3176 uint32_t entsize; // sizeof (struct _objc_property)
3177 uint32_t prop_count;
3178 struct _objc_property[prop_count];
3179 };
3180 */
3181 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3182 const Decl *Container,
3183 const ObjCContainerDecl *OCD,
3184 const ObjCCommonTypesHelper &ObjCTypes,
3185 bool IsClassProperty) {
3186 if (IsClassProperty) {
3187 // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3188 // with deployment target < 9.0.
3189 const llvm::Triple &Triple = CGM.getTarget().getTriple();
3190 if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3191 (Triple.isiOS() && Triple.isOSVersionLT(9)))
3192 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3193 }
3194
3195 SmallVector<const ObjCPropertyDecl *, 16> Properties;
3196 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3197
3198 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3199 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3200 for (auto *PD : ClassExt->properties()) {
3201 if (IsClassProperty != PD->isClassProperty())
3202 continue;
3203 PropertySet.insert(PD->getIdentifier());
3204 Properties.push_back(PD);
3205 }
3206
3207 for (const auto *PD : OCD->properties()) {
3208 if (IsClassProperty != PD->isClassProperty())
3209 continue;
3210 // Don't emit duplicate metadata for properties that were already in a
3211 // class extension.
3212 if (!PropertySet.insert(PD->getIdentifier()).second)
3213 continue;
3214 Properties.push_back(PD);
3215 }
3216
3217 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3218 for (const auto *P : OID->all_referenced_protocols())
3219 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3220 }
3221 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3222 for (const auto *P : CD->protocols())
3223 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3224 }
3225
3226 // Return null for empty list.
3227 if (Properties.empty())
3228 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3229
3230 unsigned propertySize =
3231 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3232
3233 ConstantInitBuilder builder(CGM);
3234 auto values = builder.beginStruct();
3235 values.addInt(ObjCTypes.IntTy, propertySize);
3236 values.addInt(ObjCTypes.IntTy, Properties.size());
3237 auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3238 for (auto PD : Properties) {
3239 auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3240 property.add(GetPropertyName(PD->getIdentifier()));
3241 property.add(GetPropertyTypeString(PD, Container));
3242 property.finishAndAddTo(propertiesArray);
3243 }
3244 propertiesArray.finishAndAddTo(values);
3245
3246 StringRef Section;
3247 if (CGM.getTriple().isOSBinFormatMachO())
3248 Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3249 : "__OBJC,__property,regular,no_dead_strip";
3250
3251 llvm::GlobalVariable *GV =
3252 CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3253 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3254 }
3255
3256 llvm::Constant *
3257 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3258 ArrayRef<llvm::Constant*> MethodTypes,
3259 const ObjCCommonTypesHelper &ObjCTypes) {
3260 // Return null for empty list.
3261 if (MethodTypes.empty())
3262 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3263
3264 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3265 MethodTypes.size());
3266 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3267
3268 StringRef Section;
3269 if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3270 Section = "__DATA, __objc_const";
3271
3272 llvm::GlobalVariable *GV =
3273 CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3274 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3275 }
3276
3277 /*
3278 struct _objc_category {
3279 char *category_name;
3280 char *class_name;
3281 struct _objc_method_list *instance_methods;
3282 struct _objc_method_list *class_methods;
3283 struct _objc_protocol_list *protocols;
3284 uint32_t size; // <rdar://4585769>
3285 struct _objc_property_list *instance_properties;
3286 struct _objc_property_list *class_properties;
3287 };
3288 */
3289 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3290 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3291
3292 // FIXME: This is poor design, the OCD should have a pointer to the category
3293 // decl. Additionally, note that Category can be null for the @implementation
3294 // w/o an @interface case. Sema should just create one for us as it does for
3295 // @implementation so everyone else can live life under a clear blue sky.
3296 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3297 const ObjCCategoryDecl *Category =
3298 Interface->FindCategoryDeclaration(OCD->getIdentifier());
3299
3300 SmallString<256> ExtName;
3301 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3302 << OCD->getName();
3303
3304 ConstantInitBuilder Builder(CGM);
3305 auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3306
3307 enum {
3308 InstanceMethods,
3309 ClassMethods,
3310 NumMethodLists
3311 };
3312 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3313 for (const auto *MD : OCD->methods()) {
3314 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3315 }
3316
3317 Values.add(GetClassName(OCD->getName()));
3318 Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3319 LazySymbols.insert(Interface->getIdentifier());
3320
3321 Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3322 Methods[InstanceMethods]));
3323 Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3324 Methods[ClassMethods]));
3325 if (Category) {
3326 Values.add(
3327 EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3328 Category->protocol_begin(), Category->protocol_end()));
3329 } else {
3330 Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3331 }
3332 Values.addInt(ObjCTypes.IntTy, Size);
3333
3334 // If there is no category @interface then there can be no properties.
3335 if (Category) {
3336 Values.add(EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
3337 OCD, Category, ObjCTypes, false));
3338 Values.add(EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3339 OCD, Category, ObjCTypes, true));
3340 } else {
3341 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3342 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3343 }
3344
3345 llvm::GlobalVariable *GV =
3346 CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3347 "__OBJC,__category,regular,no_dead_strip",
3348 CGM.getPointerAlign(), true);
3349 DefinedCategories.push_back(GV);
3350 DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3351 // method definition entries must be clear for next implementation.
3352 MethodDefinitions.clear();
3353 }
3354
3355 enum FragileClassFlags {
3356 /// Apparently: is not a meta-class.
3357 FragileABI_Class_Factory = 0x00001,
3358
3359 /// Is a meta-class.
3360 FragileABI_Class_Meta = 0x00002,
3361
3362 /// Has a non-trivial constructor or destructor.
3363 FragileABI_Class_HasCXXStructors = 0x02000,
3364
3365 /// Has hidden visibility.
3366 FragileABI_Class_Hidden = 0x20000,
3367
3368 /// Class implementation was compiled under ARC.
3369 FragileABI_Class_CompiledByARC = 0x04000000,
3370
3371 /// Class implementation was compiled under MRC and has MRC weak ivars.
3372 /// Exclusive with CompiledByARC.
3373 FragileABI_Class_HasMRCWeakIvars = 0x08000000,
3374 };
3375
3376 enum NonFragileClassFlags {
3377 /// Is a meta-class.
3378 NonFragileABI_Class_Meta = 0x00001,
3379
3380 /// Is a root class.
3381 NonFragileABI_Class_Root = 0x00002,
3382
3383 /// Has a non-trivial constructor or destructor.
3384 NonFragileABI_Class_HasCXXStructors = 0x00004,
3385
3386 /// Has hidden visibility.
3387 NonFragileABI_Class_Hidden = 0x00010,
3388
3389 /// Has the exception attribute.
3390 NonFragileABI_Class_Exception = 0x00020,
3391
3392 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3393 NonFragileABI_Class_HasIvarReleaser = 0x00040,
3394
3395 /// Class implementation was compiled under ARC.
3396 NonFragileABI_Class_CompiledByARC = 0x00080,
3397
3398 /// Class has non-trivial destructors, but zero-initialization is okay.
3399 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3400
3401 /// Class implementation was compiled under MRC and has MRC weak ivars.
3402 /// Exclusive with CompiledByARC.
3403 NonFragileABI_Class_HasMRCWeakIvars = 0x00200,
3404 };
3405
3406 static bool hasWeakMember(QualType type) {
3407 if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3408 return true;
3409 }
3410
3411 if (auto recType = type->getAs<RecordType>()) {
3412 for (auto field : recType->getDecl()->fields()) {
3413 if (hasWeakMember(field->getType()))
3414 return true;
3415 }
3416 }
3417
3418 return false;
3419 }
3420
3421 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3422 /// (and actually fill in a layout string) if we really do have any
3423 /// __weak ivars.
3424 static bool hasMRCWeakIvars(CodeGenModule &CGM,
3425 const ObjCImplementationDecl *ID) {
3426 if (!CGM.getLangOpts().ObjCWeak) return false;
3427 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3428
3429 for (const ObjCIvarDecl *ivar =
3430 ID->getClassInterface()->all_declared_ivar_begin();
3431 ivar; ivar = ivar->getNextIvar()) {
3432 if (hasWeakMember(ivar->getType()))
3433 return true;
3434 }
3435
3436 return false;
3437 }
3438
3439 /*
3440 struct _objc_class {
3441 Class isa;
3442 Class super_class;
3443 const char *name;
3444 long version;
3445 long info;
3446 long instance_size;
3447 struct _objc_ivar_list *ivars;
3448 struct _objc_method_list *methods;
3449 struct _objc_cache *cache;
3450 struct _objc_protocol_list *protocols;
3451 // Objective-C 1.0 extensions (<rdr://4585769>)
3452 const char *ivar_layout;
3453 struct _objc_class_ext *ext;
3454 };
3455
3456 See EmitClassExtension();
3457 */
3458 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3459 IdentifierInfo *RuntimeName =
3460 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3461 DefinedSymbols.insert(RuntimeName);
3462
3463 std::string ClassName = ID->getNameAsString();
3464 // FIXME: Gross
3465 ObjCInterfaceDecl *Interface =
3466 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3467 llvm::Constant *Protocols =
3468 EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3469 Interface->all_referenced_protocol_begin(),
3470 Interface->all_referenced_protocol_end());
3471 unsigned Flags = FragileABI_Class_Factory;
3472 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3473 Flags |= FragileABI_Class_HasCXXStructors;
3474
3475 bool hasMRCWeak = false;
3476
3477 if (CGM.getLangOpts().ObjCAutoRefCount)
3478 Flags |= FragileABI_Class_CompiledByARC;
3479 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3480 Flags |= FragileABI_Class_HasMRCWeakIvars;
3481
3482 CharUnits Size =
3483 CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3484
3485 // FIXME: Set CXX-structors flag.
3486 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3487 Flags |= FragileABI_Class_Hidden;
3488
3489 enum {
3490 InstanceMethods,
3491 ClassMethods,
3492 NumMethodLists
3493 };
3494 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3495 for (const auto *MD : ID->methods()) {
3496 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3497 }
3498
3499 for (const auto *PID : ID->property_impls()) {
3500 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3501 ObjCPropertyDecl *PD = PID->getPropertyDecl();
3502
3503 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
3504 if (GetMethodDefinition(MD))
3505 Methods[InstanceMethods].push_back(MD);
3506 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
3507 if (GetMethodDefinition(MD))
3508 Methods[InstanceMethods].push_back(MD);
3509 }
3510 }
3511
3512 ConstantInitBuilder builder(CGM);
3513 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3514 values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3515 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3516 // Record a reference to the super class.
3517 LazySymbols.insert(Super->getIdentifier());
3518
3519 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3520 ObjCTypes.ClassPtrTy);
3521 } else {
3522 values.addNullPointer(ObjCTypes.ClassPtrTy);
3523 }
3524 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3525 // Version is always 0.
3526 values.addInt(ObjCTypes.LongTy, 0);
3527 values.addInt(ObjCTypes.LongTy, Flags);
3528 values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3529 values.add(EmitIvarList(ID, false));
3530 values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3531 Methods[InstanceMethods]));
3532 // cache is always NULL.
3533 values.addNullPointer(ObjCTypes.CachePtrTy);
3534 values.add(Protocols);
3535 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3536 values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3537 /*isMetaclass*/ false));
3538
3539 std::string Name("OBJC_CLASS_");
3540 Name += ClassName;
3541 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3542 // Check for a forward reference.
3543 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3544 if (GV) {
3545 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3546 "Forward metaclass reference has incorrect type.");
3547 values.finishAndSetAsInitializer(GV);
3548 GV->setSection(Section);
3549 GV->setAlignment(CGM.getPointerAlign().getQuantity());
3550 CGM.addCompilerUsedGlobal(GV);
3551 } else
3552 GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3553 DefinedClasses.push_back(GV);
3554 ImplementedClasses.push_back(Interface);
3555 // method definition entries must be clear for next implementation.
3556 MethodDefinitions.clear();
3557 }
3558
3559 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3560 llvm::Constant *Protocols,
3561 ArrayRef<const ObjCMethodDecl*> Methods) {
3562 unsigned Flags = FragileABI_Class_Meta;
3563 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3564
3565 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3566 Flags |= FragileABI_Class_Hidden;
3567
3568 ConstantInitBuilder builder(CGM);
3569 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3570 // The isa for the metaclass is the root of the hierarchy.
3571 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3572 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3573 Root = Super;
3574 values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3575 ObjCTypes.ClassPtrTy);
3576 // The super class for the metaclass is emitted as the name of the
3577 // super class. The runtime fixes this up to point to the
3578 // *metaclass* for the super class.
3579 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3580 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3581 ObjCTypes.ClassPtrTy);
3582 } else {
3583 values.addNullPointer(ObjCTypes.ClassPtrTy);
3584 }
3585 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3586 // Version is always 0.
3587 values.addInt(ObjCTypes.LongTy, 0);
3588 values.addInt(ObjCTypes.LongTy, Flags);
3589 values.addInt(ObjCTypes.LongTy, Size);
3590 values.add(EmitIvarList(ID, true));
3591 values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3592 Methods));
3593 // cache is always NULL.
3594 values.addNullPointer(ObjCTypes.CachePtrTy);
3595 values.add(Protocols);
3596 // ivar_layout for metaclass is always NULL.
3597 values.addNullPointer(ObjCTypes.Int8PtrTy);
3598 // The class extension is used to store class properties for metaclasses.
3599 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3600 /*isMetaclass*/true));
3601
3602 std::string Name("OBJC_METACLASS_");
3603 Name += ID->getName();
3604
3605 // Check for a forward reference.
3606 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3607 if (GV) {
3608 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3609 "Forward metaclass reference has incorrect type.");
3610 values.finishAndSetAsInitializer(GV);
3611 } else {
3612 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3613 /*constant*/ false,
3614 llvm::GlobalValue::PrivateLinkage);
3615 }
3616 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3617 CGM.addCompilerUsedGlobal(GV);
3618
3619 return GV;
3620 }
3621
3622 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3623 std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3624
3625 // FIXME: Should we look these up somewhere other than the module. Its a bit
3626 // silly since we only generate these while processing an implementation, so
3627 // exactly one pointer would work if know when we entered/exitted an
3628 // implementation block.
3629
3630 // Check for an existing forward reference.
3631 // Previously, metaclass with internal linkage may have been defined.
3632 // pass 'true' as 2nd argument so it is returned.
3633 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3634 if (!GV)
3635 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3636 llvm::GlobalValue::PrivateLinkage, nullptr,
3637 Name);
3638
3639 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3640 "Forward metaclass reference has incorrect type.");
3641 return GV;
3642 }
3643
3644 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3645 std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3646 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3647
3648 if (!GV)
3649 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3650 llvm::GlobalValue::PrivateLinkage, nullptr,
3651 Name);
3652
3653 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3654 "Forward class metadata reference has incorrect type.");
3655 return GV;
3656 }
3657
3658 /*
3659 Emit a "class extension", which in this specific context means extra
3660 data that doesn't fit in the normal fragile-ABI class structure, and
3661 has nothing to do with the language concept of a class extension.
3662
3663 struct objc_class_ext {
3664 uint32_t size;
3665 const char *weak_ivar_layout;
3666 struct _objc_property_list *properties;
3667 };
3668 */
3669 llvm::Constant *
3670 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3671 CharUnits InstanceSize, bool hasMRCWeakIvars,
3672 bool isMetaclass) {
3673 // Weak ivar layout.
3674 llvm::Constant *layout;
3675 if (isMetaclass) {
3676 layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3677 } else {
3678 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3679 hasMRCWeakIvars);
3680 }
3681
3682 // Properties.
3683 llvm::Constant *propertyList =
3684 EmitPropertyList((isMetaclass ? Twine("\01l_OBJC_$_CLASS_PROP_LIST_")
3685 : Twine("\01l_OBJC_$_PROP_LIST_"))
3686 + ID->getName(),
3687 ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3688
3689 // Return null if no extension bits are used.
3690 if (layout->isNullValue() && propertyList->isNullValue()) {
3691 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3692 }
3693
3694 uint64_t size =
3695 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3696
3697 ConstantInitBuilder builder(CGM);
3698 auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3699 values.addInt(ObjCTypes.IntTy, size);
3700 values.add(layout);
3701 values.add(propertyList);
3702
3703 return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3704 "__OBJC,__class_ext,regular,no_dead_strip",
3705 CGM.getPointerAlign(), true);
3706 }
3707
3708 /*
3709 struct objc_ivar {
3710 char *ivar_name;
3711 char *ivar_type;
3712 int ivar_offset;
3713 };
3714
3715 struct objc_ivar_list {
3716 int ivar_count;
3717 struct objc_ivar list[count];
3718 };
3719 */
3720 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3721 bool ForClass) {
3722 // When emitting the root class GCC emits ivar entries for the
3723 // actual class structure. It is not clear if we need to follow this
3724 // behavior; for now lets try and get away with not doing it. If so,
3725 // the cleanest solution would be to make up an ObjCInterfaceDecl
3726 // for the class.
3727 if (ForClass)
3728 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3729
3730 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3731
3732 ConstantInitBuilder builder(CGM);
3733 auto ivarList = builder.beginStruct();
3734 auto countSlot = ivarList.addPlaceholder();
3735 auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3736
3737 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3738 IVD; IVD = IVD->getNextIvar()) {
3739 // Ignore unnamed bit-fields.
3740 if (!IVD->getDeclName())
3741 continue;
3742
3743 auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3744 ivar.add(GetMethodVarName(IVD->getIdentifier()));
3745 ivar.add(GetMethodVarType(IVD));
3746 ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3747 ivar.finishAndAddTo(ivars);
3748 }
3749
3750 // Return null for empty list.
3751 auto count = ivars.size();
3752 if (count == 0) {
3753 ivars.abandon();
3754 ivarList.abandon();
3755 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3756 }
3757
3758 ivars.finishAndAddTo(ivarList);
3759 ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3760
3761 llvm::GlobalVariable *GV;
3762 if (ForClass)
3763 GV =
3764 CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3765 "__OBJC,__class_vars,regular,no_dead_strip",
3766 CGM.getPointerAlign(), true);
3767 else
3768 GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3769 "__OBJC,__instance_vars,regular,no_dead_strip",
3770 CGM.getPointerAlign(), true);
3771 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3772 }
3773
3774 /// Build a struct objc_method_description constant for the given method.
3775 ///
3776 /// struct objc_method_description {
3777 /// SEL method_name;
3778 /// char *method_types;
3779 /// };
3780 void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3781 const ObjCMethodDecl *MD) {
3782 auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3783 description.addBitCast(GetMethodVarName(MD->getSelector()),
3784 ObjCTypes.SelectorPtrTy);
3785 description.add(GetMethodVarType(MD));
3786 description.finishAndAddTo(builder);
3787 }
3788
3789 /// Build a struct objc_method constant for the given method.
3790 ///
3791 /// struct objc_method {
3792 /// SEL method_name;
3793 /// char *method_types;
3794 /// void *method;
3795 /// };
3796 void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3797 const ObjCMethodDecl *MD) {
3798 llvm::Function *fn = GetMethodDefinition(MD);
3799 assert(fn && "no definition registered for method");
3800
3801 auto method = builder.beginStruct(ObjCTypes.MethodTy);
3802 method.addBitCast(GetMethodVarName(MD->getSelector()),
3803 ObjCTypes.SelectorPtrTy);
3804 method.add(GetMethodVarType(MD));
3805 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3806 method.finishAndAddTo(builder);
3807 }
3808
3809 /// Build a struct objc_method_list or struct objc_method_description_list,
3810 /// as appropriate.
3811 ///
3812 /// struct objc_method_list {
3813 /// struct objc_method_list *obsolete;
3814 /// int count;
3815 /// struct objc_method methods_list[count];
3816 /// };
3817 ///
3818 /// struct objc_method_description_list {
3819 /// int count;
3820 /// struct objc_method_description list[count];
3821 /// };
3822 llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3823 ArrayRef<const ObjCMethodDecl *> methods) {
3824 StringRef prefix;
3825 StringRef section;
3826 bool forProtocol = false;
3827 switch (MLT) {
3828 case MethodListType::CategoryInstanceMethods:
3829 prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3830 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3831 forProtocol = false;
3832 break;
3833 case MethodListType::CategoryClassMethods:
3834 prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3835 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3836 forProtocol = false;
3837 break;
3838 case MethodListType::InstanceMethods:
3839 prefix = "OBJC_INSTANCE_METHODS_";
3840 section = "__OBJC,__inst_meth,regular,no_dead_strip";
3841 forProtocol = false;
3842 break;
3843 case MethodListType::ClassMethods:
3844 prefix = "OBJC_CLASS_METHODS_";
3845 section = "__OBJC,__cls_meth,regular,no_dead_strip";
3846 forProtocol = false;
3847 break;
3848 case MethodListType::ProtocolInstanceMethods:
3849 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3850 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3851 forProtocol = true;
3852 break;
3853 case MethodListType::ProtocolClassMethods:
3854 prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3855 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3856 forProtocol = true;
3857 break;
3858 case MethodListType::OptionalProtocolInstanceMethods:
3859 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3860 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3861 forProtocol = true;
3862 break;
3863 case MethodListType::OptionalProtocolClassMethods:
3864 prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3865 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3866 forProtocol = true;
3867 break;
3868 }
3869
3870 // Return null for empty list.
3871 if (methods.empty())
3872 return llvm::Constant::getNullValue(forProtocol
3873 ? ObjCTypes.MethodDescriptionListPtrTy
3874 : ObjCTypes.MethodListPtrTy);
3875
3876 // For protocols, this is an objc_method_description_list, which has
3877 // a slightly different structure.
3878 if (forProtocol) {
3879 ConstantInitBuilder builder(CGM);
3880 auto values = builder.beginStruct();
3881 values.addInt(ObjCTypes.IntTy, methods.size());
3882 auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3883 for (auto MD : methods) {
3884 emitMethodDescriptionConstant(methodArray, MD);
3885 }
3886 methodArray.finishAndAddTo(values);
3887
3888 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3889 CGM.getPointerAlign(), true);
3890 return llvm::ConstantExpr::getBitCast(GV,
3891 ObjCTypes.MethodDescriptionListPtrTy);
3892 }
3893
3894 // Otherwise, it's an objc_method_list.
3895 ConstantInitBuilder builder(CGM);
3896 auto values = builder.beginStruct();
3897 values.addNullPointer(ObjCTypes.Int8PtrTy);
3898 values.addInt(ObjCTypes.IntTy, methods.size());
3899 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
3900 for (auto MD : methods) {
3901 emitMethodConstant(methodArray, MD);
3902 }
3903 methodArray.finishAndAddTo(values);
3904
3905 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3906 CGM.getPointerAlign(), true);
3907 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3908 }
3909
3910 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3911 const ObjCContainerDecl *CD) {
3912 SmallString<256> Name;
3913 GetNameForMethod(OMD, CD, Name);
3914
3915 CodeGenTypes &Types = CGM.getTypes();
3916 llvm::FunctionType *MethodTy =
3917 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
3918 llvm::Function *Method =
3919 llvm::Function::Create(MethodTy,
3920 llvm::GlobalValue::InternalLinkage,
3921 Name.str(),
3922 &CGM.getModule());
3923 MethodDefinitions.insert(std::make_pair(OMD, Method));
3924
3925 return Method;
3926 }
3927
3928 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3929 ConstantStructBuilder &Init,
3930 StringRef Section,
3931 CharUnits Align,
3932 bool AddToUsed) {
3933 llvm::GlobalVariable *GV =
3934 Init.finishAndCreateGlobal(Name, Align, /*constant*/ false,
3935 llvm::GlobalValue::PrivateLinkage);
3936 if (!Section.empty())
3937 GV->setSection(Section);
3938 if (AddToUsed)
3939 CGM.addCompilerUsedGlobal(GV);
3940 return GV;
3941 }
3942
3943 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3944 llvm::Constant *Init,
3945 StringRef Section,
3946 CharUnits Align,
3947 bool AddToUsed) {
3948 llvm::Type *Ty = Init->getType();
3949 llvm::GlobalVariable *GV =
3950 new llvm::GlobalVariable(CGM.getModule(), Ty, false,
3951 llvm::GlobalValue::PrivateLinkage, Init, Name);
3952 if (!Section.empty())
3953 GV->setSection(Section);
3954 GV->setAlignment(Align.getQuantity());
3955 if (AddToUsed)
3956 CGM.addCompilerUsedGlobal(GV);
3957 return GV;
3958 }
3959
3960 llvm::GlobalVariable *
3961 CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
3962 bool ForceNonFragileABI,
3963 bool NullTerminate) {
3964 StringRef Label;
3965 switch (Type) {
3966 case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break;
3967 case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
3968 case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
3969 case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break;
3970 }
3971
3972 bool NonFragile = ForceNonFragileABI || isNonFragileABI();
3973
3974 StringRef Section;
3975 switch (Type) {
3976 case ObjCLabelType::ClassName:
3977 Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
3978 : "__TEXT,__cstring,cstring_literals";
3979 break;
3980 case ObjCLabelType::MethodVarName:
3981 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
3982 : "__TEXT,__cstring,cstring_literals";
3983 break;
3984 case ObjCLabelType::MethodVarType:
3985 Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
3986 : "__TEXT,__cstring,cstring_literals";
3987 break;
3988 case ObjCLabelType::PropertyName:
3989 Section = "__TEXT,__cstring,cstring_literals";
3990 break;
3991 }
3992
3993 llvm::Constant *Value =
3994 llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
3995 llvm::GlobalVariable *GV =
3996 new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
3997 /*isConstant=*/true,
3998 llvm::GlobalValue::PrivateLinkage, Value, Label);
3999 if (CGM.getTriple().isOSBinFormatMachO())
4000 GV->setSection(Section);
4001 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4002 GV->setAlignment(CharUnits::One().getQuantity());
4003 CGM.addCompilerUsedGlobal(GV);
4004
4005 return GV;
4006 }
4007
4008 llvm::Function *CGObjCMac::ModuleInitFunction() {
4009 // Abuse this interface function as a place to finalize.
4010 FinishModule();
4011 return nullptr;
4012 }
4013
4014 llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
4015 return ObjCTypes.getGetPropertyFn();
4016 }
4017
4018 llvm::Constant *CGObjCMac::GetPropertySetFunction() {
4019 return ObjCTypes.getSetPropertyFn();
4020 }
4021
4022 llvm::Constant *CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4023 bool copy) {
4024 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4025 }
4026
4027 llvm::Constant *CGObjCMac::GetGetStructFunction() {
4028 return ObjCTypes.getCopyStructFn();
4029 }
4030
4031 llvm::Constant *CGObjCMac::GetSetStructFunction() {
4032 return ObjCTypes.getCopyStructFn();
4033 }
4034
4035 llvm::Constant *CGObjCMac::GetCppAtomicObjectGetFunction() {
4036 return ObjCTypes.getCppAtomicObjectFunction();
4037 }
4038
4039 llvm::Constant *CGObjCMac::GetCppAtomicObjectSetFunction() {
4040 return ObjCTypes.getCppAtomicObjectFunction();
4041 }
4042
4043 llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
4044 return ObjCTypes.getEnumerationMutationFn();
4045 }
4046
4047 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4048 return EmitTryOrSynchronizedStmt(CGF, S);
4049 }
4050
4051 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4052 const ObjCAtSynchronizedStmt &S) {
4053 return EmitTryOrSynchronizedStmt(CGF, S);
4054 }
4055
4056 namespace {
4057 struct PerformFragileFinally final : EHScopeStack::Cleanup {
4058 const Stmt &S;
4059 Address SyncArgSlot;
4060 Address CallTryExitVar;
4061 Address ExceptionData;
4062 ObjCTypesHelper &ObjCTypes;
4063 PerformFragileFinally(const Stmt *S,
4064 Address SyncArgSlot,
4065 Address CallTryExitVar,
4066 Address ExceptionData,
4067 ObjCTypesHelper *ObjCTypes)
4068 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4069 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4070
4071 void Emit(CodeGenFunction &CGF, Flags flags) override {
4072 // Check whether we need to call objc_exception_try_exit.
4073 // In optimized code, this branch will always be folded.
4074 llvm::BasicBlock *FinallyCallExit =
4075 CGF.createBasicBlock("finally.call_exit");
4076 llvm::BasicBlock *FinallyNoCallExit =
4077 CGF.createBasicBlock("finally.no_call_exit");
4078 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4079 FinallyCallExit, FinallyNoCallExit);
4080
4081 CGF.EmitBlock(FinallyCallExit);
4082 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4083 ExceptionData.getPointer());
4084
4085 CGF.EmitBlock(FinallyNoCallExit);
4086
4087 if (isa<ObjCAtTryStmt>(S)) {
4088 if (const ObjCAtFinallyStmt* FinallyStmt =
4089 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4090 // Don't try to do the @finally if this is an EH cleanup.
4091 if (flags.isForEHCleanup()) return;
4092
4093 // Save the current cleanup destination in case there's
4094 // control flow inside the finally statement.
4095 llvm::Value *CurCleanupDest =
4096 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4097
4098 CGF.EmitStmt(FinallyStmt->getFinallyBody());
4099
4100 if (CGF.HaveInsertPoint()) {
4101 CGF.Builder.CreateStore(CurCleanupDest,
4102 CGF.getNormalCleanupDestSlot());
4103 } else {
4104 // Currently, the end of the cleanup must always exist.
4105 CGF.EnsureInsertPoint();
4106 }
4107 }
4108 } else {
4109 // Emit objc_sync_exit(expr); as finally's sole statement for
4110 // @synchronized.
4111 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4112 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4113 }
4114 }
4115 };
4116
4117 class FragileHazards {
4118 CodeGenFunction &CGF;
4119 SmallVector<llvm::Value*, 20> Locals;
4120 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4121
4122 llvm::InlineAsm *ReadHazard;
4123 llvm::InlineAsm *WriteHazard;
4124
4125 llvm::FunctionType *GetAsmFnType();
4126
4127 void collectLocals();
4128 void emitReadHazard(CGBuilderTy &Builder);
4129
4130 public:
4131 FragileHazards(CodeGenFunction &CGF);
4132
4133 void emitWriteHazard();
4134 void emitHazardsInNewBlocks();
4135 };
4136 } // end anonymous namespace
4137
4138 /// Create the fragile-ABI read and write hazards based on the current
4139 /// state of the function, which is presumed to be immediately prior
4140 /// to a @try block. These hazards are used to maintain correct
4141 /// semantics in the face of optimization and the fragile ABI's
4142 /// cavalier use of setjmp/longjmp.
4143 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4144 collectLocals();
4145
4146 if (Locals.empty()) return;
4147
4148 // Collect all the blocks in the function.
4149 for (llvm::Function::iterator
4150 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4151 BlocksBeforeTry.insert(&*I);
4152
4153 llvm::FunctionType *AsmFnTy = GetAsmFnType();
4154
4155 // Create a read hazard for the allocas. This inhibits dead-store
4156 // optimizations and forces the values to memory. This hazard is
4157 // inserted before any 'throwing' calls in the protected scope to
4158 // reflect the possibility that the variables might be read from the
4159 // catch block if the call throws.
4160 {
4161 std::string Constraint;
4162 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4163 if (I) Constraint += ',';
4164 Constraint += "*m";
4165 }
4166
4167 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4168 }
4169
4170 // Create a write hazard for the allocas. This inhibits folding
4171 // loads across the hazard. This hazard is inserted at the
4172 // beginning of the catch path to reflect the possibility that the
4173 // variables might have been written within the protected scope.
4174 {
4175 std::string Constraint;
4176 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4177 if (I) Constraint += ',';
4178 Constraint += "=*m";
4179 }
4180
4181 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4182 }
4183 }
4184
4185 /// Emit a write hazard at the current location.
4186 void FragileHazards::emitWriteHazard() {
4187 if (Locals.empty()) return;
4188
4189 CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4190 }
4191
4192 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4193 assert(!Locals.empty());
4194 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4195 call->setDoesNotThrow();
4196 call->setCallingConv(CGF.getRuntimeCC());
4197 }
4198
4199 /// Emit read hazards in all the protected blocks, i.e. all the blocks
4200 /// which have been inserted since the beginning of the try.
4201 void FragileHazards::emitHazardsInNewBlocks() {
4202 if (Locals.empty()) return;
4203
4204 CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4205
4206 // Iterate through all blocks, skipping those prior to the try.
4207 for (llvm::Function::iterator
4208 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4209 llvm::BasicBlock &BB = *FI;
4210 if (BlocksBeforeTry.count(&BB)) continue;
4211
4212 // Walk through all the calls in the block.
4213 for (llvm::BasicBlock::iterator
4214 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4215 llvm::Instruction &I = *BI;
4216
4217 // Ignore instructions that aren't non-intrinsic calls.
4218 // These are the only calls that can possibly call longjmp.
4219 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) continue;
4220 if (isa<llvm::IntrinsicInst>(I))
4221 continue;
4222
4223 // Ignore call sites marked nounwind. This may be questionable,
4224 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4225 llvm::CallSite CS(&I);
4226 if (CS.doesNotThrow()) continue;
4227
4228 // Insert a read hazard before the call. This will ensure that
4229 // any writes to the locals are performed before making the
4230 // call. If the call throws, then this is sufficient to
4231 // guarantee correctness as long as it doesn't also write to any
4232 // locals.
4233 Builder.SetInsertPoint(&BB, BI);
4234 emitReadHazard(Builder);
4235 }
4236 }
4237 }
4238
4239 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4240 if (V.isValid()) S.insert(V.getPointer());
4241 }
4242
4243 void FragileHazards::collectLocals() {
4244 // Compute a set of allocas to ignore.
4245 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4246 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4247 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4248
4249 // Collect all the allocas currently in the function. This is
4250 // probably way too aggressive.
4251 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4252 for (llvm::BasicBlock::iterator
4253 I = Entry.begin(), E = Entry.end(); I != E; ++I)
4254 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4255 Locals.push_back(&*I);
4256 }
4257
4258 llvm::FunctionType *FragileHazards::GetAsmFnType() {
4259 SmallVector<llvm::Type *, 16> tys(Locals.size());
4260 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4261 tys[i] = Locals[i]->getType();
4262 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4263 }
4264
4265 /*
4266
4267 Objective-C setjmp-longjmp (sjlj) Exception Handling
4268 --
4269
4270 A catch buffer is a setjmp buffer plus:
4271 - a pointer to the exception that was caught
4272 - a pointer to the previous exception data buffer
4273 - two pointers of reserved storage
4274 Therefore catch buffers form a stack, with a pointer to the top
4275 of the stack kept in thread-local storage.
4276
4277 objc_exception_try_enter pushes a catch buffer onto the EH stack.
4278 objc_exception_try_exit pops the given catch buffer, which is
4279 required to be the top of the EH stack.
4280 objc_exception_throw pops the top of the EH stack, writes the
4281 thrown exception into the appropriate field, and longjmps
4282 to the setjmp buffer. It crashes the process (with a printf
4283 and an abort()) if there are no catch buffers on the stack.
4284 objc_exception_extract just reads the exception pointer out of the
4285 catch buffer.
4286
4287 There's no reason an implementation couldn't use a light-weight
4288 setjmp here --- something like __builtin_setjmp, but API-compatible
4289 with the heavyweight setjmp. This will be more important if we ever
4290 want to implement correct ObjC/C++ exception interactions for the
4291 fragile ABI.
4292
4293 Note that for this use of setjmp/longjmp to be correct, we may need
4294 to mark some local variables volatile: if a non-volatile local
4295 variable is modified between the setjmp and the longjmp, it has
4296 indeterminate value. For the purposes of LLVM IR, it may be
4297 sufficient to make loads and stores within the @try (to variables
4298 declared outside the @try) volatile. This is necessary for
4299 optimized correctness, but is not currently being done; this is
4300 being tracked as rdar://problem/8160285
4301
4302 The basic framework for a @try-catch-finally is as follows:
4303 {
4304 objc_exception_data d;
4305 id _rethrow = null;
4306 bool _call_try_exit = true;
4307
4308 objc_exception_try_enter(&d);
4309 if (!setjmp(d.jmp_buf)) {
4310 ... try body ...
4311 } else {
4312 // exception path
4313 id _caught = objc_exception_extract(&d);
4314
4315 // enter new try scope for handlers
4316 if (!setjmp(d.jmp_buf)) {
4317 ... match exception and execute catch blocks ...
4318
4319 // fell off end, rethrow.
4320 _rethrow = _caught;
4321 ... jump-through-finally to finally_rethrow ...
4322 } else {
4323 // exception in catch block
4324 _rethrow = objc_exception_extract(&d);
4325 _call_try_exit = false;
4326 ... jump-through-finally to finally_rethrow ...
4327 }
4328 }
4329 ... jump-through-finally to finally_end ...
4330
4331 finally:
4332 if (_call_try_exit)
4333 objc_exception_try_exit(&d);
4334
4335 ... finally block ....
4336 ... dispatch to finally destination ...
4337
4338 finally_rethrow:
4339 objc_exception_throw(_rethrow);
4340
4341 finally_end:
4342 }
4343
4344 This framework differs slightly from the one gcc uses, in that gcc
4345 uses _rethrow to determine if objc_exception_try_exit should be called
4346 and if the object should be rethrown. This breaks in the face of
4347 throwing nil and introduces unnecessary branches.
4348
4349 We specialize this framework for a few particular circumstances:
4350
4351 - If there are no catch blocks, then we avoid emitting the second
4352 exception handling context.
4353
4354 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4355 e)) we avoid emitting the code to rethrow an uncaught exception.
4356
4357 - FIXME: If there is no @finally block we can do a few more
4358 simplifications.
4359
4360 Rethrows and Jumps-Through-Finally
4361 --
4362
4363 '@throw;' is supported by pushing the currently-caught exception
4364 onto ObjCEHStack while the @catch blocks are emitted.
4365
4366 Branches through the @finally block are handled with an ordinary
4367 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4368 exceptions are not compatible with C++ exceptions, and this is
4369 hardly the only place where this will go wrong.
4370
4371 @synchronized(expr) { stmt; } is emitted as if it were:
4372 id synch_value = expr;
4373 objc_sync_enter(synch_value);
4374 @try { stmt; } @finally { objc_sync_exit(synch_value); }
4375 */
4376
4377 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4378 const Stmt &S) {
4379 bool isTry = isa<ObjCAtTryStmt>(S);
4380
4381 // A destination for the fall-through edges of the catch handlers to
4382 // jump to.
4383 CodeGenFunction::JumpDest FinallyEnd =
4384 CGF.getJumpDestInCurrentScope("finally.end");
4385
4386 // A destination for the rethrow edge of the catch handlers to jump
4387 // to.
4388 CodeGenFunction::JumpDest FinallyRethrow =
4389 CGF.getJumpDestInCurrentScope("finally.rethrow");
4390
4391 // For @synchronized, call objc_sync_enter(sync.expr). The
4392 // evaluation of the expression must occur before we enter the
4393 // @synchronized. We can't avoid a temp here because we need the
4394 // value to be preserved. If the backend ever does liveness
4395 // correctly after setjmp, this will be unnecessary.
4396 Address SyncArgSlot = Address::invalid();
4397 if (!isTry) {
4398 llvm::Value *SyncArg =
4399 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4400 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4401 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4402
4403 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4404 CGF.getPointerAlign(), "sync.arg");
4405 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4406 }
4407
4408 // Allocate memory for the setjmp buffer. This needs to be kept
4409 // live throughout the try and catch blocks.
4410 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4411 CGF.getPointerAlign(),
4412 "exceptiondata.ptr");
4413
4414 // Create the fragile hazards. Note that this will not capture any
4415 // of the allocas required for exception processing, but will
4416 // capture the current basic block (which extends all the way to the
4417 // setjmp call) as "before the @try".
4418 FragileHazards Hazards(CGF);
4419
4420 // Create a flag indicating whether the cleanup needs to call
4421 // objc_exception_try_exit. This is true except when
4422 // - no catches match and we're branching through the cleanup
4423 // just to rethrow the exception, or
4424 // - a catch matched and we're falling out of the catch handler.
4425 // The setjmp-safety rule here is that we should always store to this
4426 // variable in a place that dominates the branch through the cleanup
4427 // without passing through any setjmps.
4428 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4429 CharUnits::One(),
4430 "_call_try_exit");
4431
4432 // A slot containing the exception to rethrow. Only needed when we
4433 // have both a @catch and a @finally.
4434 Address PropagatingExnVar = Address::invalid();
4435
4436 // Push a normal cleanup to leave the try scope.
4437 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4438 SyncArgSlot,
4439 CallTryExitVar,
4440 ExceptionData,
4441 &ObjCTypes);
4442
4443 // Enter a try block:
4444 // - Call objc_exception_try_enter to push ExceptionData on top of
4445 // the EH stack.
4446 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4447 ExceptionData.getPointer());
4448
4449 // - Call setjmp on the exception data buffer.
4450 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4451 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4452 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4453 ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4454 "setjmp_buffer");
4455 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4456 ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4457 SetJmpResult->setCanReturnTwice();
4458
4459 // If setjmp returned 0, enter the protected block; otherwise,
4460 // branch to the handler.
4461 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4462 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4463 llvm::Value *DidCatch =
4464 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4465 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4466
4467 // Emit the protected block.
4468 CGF.EmitBlock(TryBlock);
4469 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4470 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4471 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4472
4473 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4474
4475 // Emit the exception handler block.
4476 CGF.EmitBlock(TryHandler);
4477
4478 // Don't optimize loads of the in-scope locals across this point.
4479 Hazards.emitWriteHazard();
4480
4481 // For a @synchronized (or a @try with no catches), just branch
4482 // through the cleanup to the rethrow block.
4483 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4484 // Tell the cleanup not to re-pop the exit.
4485 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4486 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4487
4488 // Otherwise, we have to match against the caught exceptions.
4489 } else {
4490 // Retrieve the exception object. We may emit multiple blocks but
4491 // nothing can cross this so the value is already in SSA form.
4492 llvm::CallInst *Caught =
4493 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4494 ExceptionData.getPointer(), "caught");
4495
4496 // Push the exception to rethrow onto the EH value stack for the
4497 // benefit of any @throws in the handlers.
4498 CGF.ObjCEHValueStack.push_back(Caught);
4499
4500 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4501
4502 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4503
4504 llvm::BasicBlock *CatchBlock = nullptr;
4505 llvm::BasicBlock *CatchHandler = nullptr;
4506 if (HasFinally) {
4507 // Save the currently-propagating exception before
4508 // objc_exception_try_enter clears the exception slot.
4509 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4510 CGF.getPointerAlign(),
4511 "propagating_exception");
4512 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4513
4514 // Enter a new exception try block (in case a @catch block
4515 // throws an exception).
4516 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4517 ExceptionData.getPointer());
4518
4519 llvm::CallInst *SetJmpResult =
4520 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4521 SetJmpBuffer, "setjmp.result");
4522 SetJmpResult->setCanReturnTwice();
4523
4524 llvm::Value *Threw =
4525 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4526
4527 CatchBlock = CGF.createBasicBlock("catch");
4528 CatchHandler = CGF.createBasicBlock("catch_for_catch");
4529 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4530
4531 CGF.EmitBlock(CatchBlock);
4532 }
4533
4534 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4535
4536 // Handle catch list. As a special case we check if everything is
4537 // matched and avoid generating code for falling off the end if
4538 // so.
4539 bool AllMatched = false;
4540 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4541 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4542
4543 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4544 const ObjCObjectPointerType *OPT = nullptr;
4545
4546 // catch(...) always matches.
4547 if (!CatchParam) {
4548 AllMatched = true;
4549 } else {
4550 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4551
4552 // catch(id e) always matches under this ABI, since only
4553 // ObjC exceptions end up here in the first place.
4554 // FIXME: For the time being we also match id<X>; this should
4555 // be rejected by Sema instead.
4556 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4557 AllMatched = true;
4558 }
4559
4560 // If this is a catch-all, we don't need to test anything.
4561 if (AllMatched) {
4562 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4563
4564 if (CatchParam) {
4565 CGF.EmitAutoVarDecl(*CatchParam);
4566 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4567
4568 // These types work out because ConvertType(id) == i8*.
4569 EmitInitOfCatchParam(CGF, Caught, CatchParam);
4570 }
4571
4572 CGF.EmitStmt(CatchStmt->getCatchBody());
4573
4574 // The scope of the catch variable ends right here.
4575 CatchVarCleanups.ForceCleanup();
4576
4577 CGF.EmitBranchThroughCleanup(FinallyEnd);
4578 break;
4579 }
4580
4581 assert(OPT && "Unexpected non-object pointer type in @catch");
4582 const ObjCObjectType *ObjTy = OPT->getObjectType();
4583
4584 // FIXME: @catch (Class c) ?
4585 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4586 assert(IDecl && "Catch parameter must have Objective-C type!");
4587
4588 // Check if the @catch block matches the exception object.
4589 llvm::Value *Class = EmitClassRef(CGF, IDecl);
4590
4591 llvm::Value *matchArgs[] = { Class, Caught };
4592 llvm::CallInst *Match =
4593 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4594 matchArgs, "match");
4595
4596 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4597 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4598
4599 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4600 MatchedBlock, NextCatchBlock);
4601
4602 // Emit the @catch block.
4603 CGF.EmitBlock(MatchedBlock);
4604
4605 // Collect any cleanups for the catch variable. The scope lasts until
4606 // the end of the catch body.
4607 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4608
4609 CGF.EmitAutoVarDecl(*CatchParam);
4610 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4611
4612 // Initialize the catch variable.
4613 llvm::Value *Tmp =
4614 CGF.Builder.CreateBitCast(Caught,
4615 CGF.ConvertType(CatchParam->getType()));
4616 EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4617
4618 CGF.EmitStmt(CatchStmt->getCatchBody());
4619
4620 // We're done with the catch variable.
4621 CatchVarCleanups.ForceCleanup();
4622
4623 CGF.EmitBranchThroughCleanup(FinallyEnd);
4624
4625 CGF.EmitBlock(NextCatchBlock);
4626 }
4627
4628 CGF.ObjCEHValueStack.pop_back();
4629
4630 // If nothing wanted anything to do with the caught exception,
4631 // kill the extract call.
4632 if (Caught->use_empty())
4633 Caught->eraseFromParent();
4634
4635 if (!AllMatched)
4636 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4637
4638 if (HasFinally) {
4639 // Emit the exception handler for the @catch blocks.
4640 CGF.EmitBlock(CatchHandler);
4641
4642 // In theory we might now need a write hazard, but actually it's
4643 // unnecessary because there's no local-accessing code between
4644 // the try's write hazard and here.
4645 //Hazards.emitWriteHazard();
4646
4647 // Extract the new exception and save it to the
4648 // propagating-exception slot.
4649 assert(PropagatingExnVar.isValid());
4650 llvm::CallInst *NewCaught =
4651 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4652 ExceptionData.getPointer(), "caught");
4653 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4654
4655 // Don't pop the catch handler; the throw already did.
4656 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4657 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4658 }
4659 }
4660
4661 // Insert read hazards as required in the new blocks.
4662 Hazards.emitHazardsInNewBlocks();
4663
4664 // Pop the cleanup.
4665 CGF.Builder.restoreIP(TryFallthroughIP);
4666 if (CGF.HaveInsertPoint())
4667 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4668 CGF.PopCleanupBlock();
4669 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4670
4671 // Emit the rethrow block.
4672 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4673 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4674 if (CGF.HaveInsertPoint()) {
4675 // If we have a propagating-exception variable, check it.
4676 llvm::Value *PropagatingExn;
4677 if (PropagatingExnVar.isValid()) {
4678 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4679
4680 // Otherwise, just look in the buffer for the exception to throw.
4681 } else {
4682 llvm::CallInst *Caught =
4683 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4684 ExceptionData.getPointer());
4685 PropagatingExn = Caught;
4686 }
4687
4688 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4689 PropagatingExn);
4690 CGF.Builder.CreateUnreachable();
4691 }
4692
4693 CGF.Builder.restoreIP(SavedIP);
4694 }
4695
4696 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4697 const ObjCAtThrowStmt &S,
4698 bool ClearInsertionPoint) {
4699 llvm::Value *ExceptionAsObject;
4700
4701 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4702 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4703 ExceptionAsObject =
4704 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4705 } else {
4706 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4707 "Unexpected rethrow outside @catch block.");
4708 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4709 }
4710
4711 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4712 ->setDoesNotReturn();
4713 CGF.Builder.CreateUnreachable();
4714
4715 // Clear the insertion point to indicate we are in unreachable code.
4716 if (ClearInsertionPoint)
4717 CGF.Builder.ClearInsertionPoint();
4718 }
4719
4720 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4721 /// object: objc_read_weak (id *src)
4722 ///
4723 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4724 Address AddrWeakObj) {
4725 llvm::Type* DestTy = AddrWeakObj.getElementType();
4726 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4727 ObjCTypes.PtrObjectPtrTy);
4728 llvm::Value *read_weak =
4729 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4730 AddrWeakObj.getPointer(), "weakread");
4731 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4732 return read_weak;
4733 }
4734
4735 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4736 /// objc_assign_weak (id src, id *dst)
4737 ///
4738 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4739 llvm::Value *src, Address dst) {
4740 llvm::Type * SrcTy = src->getType();
4741 if (!isa<llvm::PointerType>(SrcTy)) {
4742 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4743 assert(Size <= 8 && "does not support size > 8");
4744 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4745 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4746 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4747 }
4748 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4749 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4750 llvm::Value *args[] = { src, dst.getPointer() };
4751 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4752 args, "weakassign");
4753 }
4754
4755 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4756 /// objc_assign_global (id src, id *dst)
4757 ///
4758 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4759 llvm::Value *src, Address dst,
4760 bool threadlocal) {
4761 llvm::Type * SrcTy = src->getType();
4762 if (!isa<llvm::PointerType>(SrcTy)) {
4763 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4764 assert(Size <= 8 && "does not support size > 8");
4765 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4766 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4767 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4768 }
4769 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4770 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4771 llvm::Value *args[] = { src, dst.getPointer() };
4772 if (!threadlocal)
4773 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4774 args, "globalassign");
4775 else
4776 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4777 args, "threadlocalassign");
4778 }
4779
4780 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4781 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4782 ///
4783 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4784 llvm::Value *src, Address dst,
4785 llvm::Value *ivarOffset) {
4786 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4787 llvm::Type * SrcTy = src->getType();
4788 if (!isa<llvm::PointerType>(SrcTy)) {
4789 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4790 assert(Size <= 8 && "does not support size > 8");
4791 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4792 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4793 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4794 }
4795 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4796 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4797 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
4798 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
4799 }
4800
4801 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
4802 /// objc_assign_strongCast (id src, id *dst)
4803 ///
4804 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
4805 llvm::Value *src, Address dst) {
4806 llvm::Type * SrcTy = src->getType();
4807 if (!isa<llvm::PointerType>(SrcTy)) {
4808 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4809 assert(Size <= 8 && "does not support size > 8");
4810 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4811 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4812 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4813 }
4814 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4815 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4816 llvm::Value *args[] = { src, dst.getPointer() };
4817 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
4818 args, "strongassign");
4819 }
4820
4821 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
4822 Address DestPtr,
4823 Address SrcPtr,
4824 llvm::Value *size) {
4825 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4826 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
4827 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
4828 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
4829 }
4830
4831 /// EmitObjCValueForIvar - Code Gen for ivar reference.
4832 ///
4833 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
4834 QualType ObjectTy,
4835 llvm::Value *BaseValue,
4836 const ObjCIvarDecl *Ivar,
4837 unsigned CVRQualifiers) {
4838 const ObjCInterfaceDecl *ID =
4839 ObjectTy->getAs<ObjCObjectType>()->getInterface();
4840 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4841 EmitIvarOffset(CGF, ID, Ivar));
4842 }
4843
4844 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
4845 const ObjCInterfaceDecl *Interface,
4846 const ObjCIvarDecl *Ivar) {
4847 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
4848 return llvm::ConstantInt::get(
4849 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
4850 Offset);
4851 }
4852
4853 /* *** Private Interface *** */
4854
4855 std::string CGObjCCommonMac::GetSectionName(StringRef Section,
4856 StringRef MachOAttributes) {
4857 switch (CGM.getTriple().getObjectFormat()) {
4858 default:
4859 llvm_unreachable("unexpected object file format");
4860 case llvm::Triple::MachO: {
4861 if (MachOAttributes.empty())
4862 return ("__DATA," + Section).str();
4863 return ("__DATA," + Section + "," + MachOAttributes).str();
4864 }
4865 case llvm::Triple::ELF:
4866 assert(Section.substr(0, 2) == "__" &&
4867 "expected the name to begin with __");
4868 return Section.substr(2).str();
4869 case llvm::Triple::COFF:
4870 assert(Section.substr(0, 2) == "__" &&
4871 "expected the name to begin with __");
4872 return ("." + Section.substr(2) + "$B").str();
4873 }
4874 }
4875
4876 /// EmitImageInfo - Emit the image info marker used to encode some module
4877 /// level information.
4878 ///
4879 /// See: <rdr://4810609&4810587&4810587>
4880 /// struct IMAGE_INFO {
4881 /// unsigned version;
4882 /// unsigned flags;
4883 /// };
4884 enum ImageInfoFlags {
4885 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
4886 eImageInfo_GarbageCollected = (1 << 1),
4887 eImageInfo_GCOnly = (1 << 2),
4888 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
4889
4890 // A flag indicating that the module has no instances of a @synthesize of a
4891 // superclass variable. <rdar://problem/6803242>
4892 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
4893 eImageInfo_ImageIsSimulated = (1 << 5),
4894 eImageInfo_ClassProperties = (1 << 6)
4895 };
4896
4897 void CGObjCCommonMac::EmitImageInfo() {
4898 unsigned version = 0; // Version is unused?
4899 std::string Section =
4900 (ObjCABI == 1)
4901 ? "__OBJC,__image_info,regular"
4902 : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
4903
4904 // Generate module-level named metadata to convey this information to the
4905 // linker and code-gen.
4906 llvm::Module &Mod = CGM.getModule();
4907
4908 // Add the ObjC ABI version to the module flags.
4909 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4910 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4911 version);
4912 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4913 llvm::MDString::get(VMContext, Section));
4914
4915 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
4916 // Non-GC overrides those files which specify GC.
4917 Mod.addModuleFlag(llvm::Module::Override,
4918 "Objective-C Garbage Collection", (uint32_t)0);
4919 } else {
4920 // Add the ObjC garbage collection value.
4921 Mod.addModuleFlag(llvm::Module::Error,
4922 "Objective-C Garbage Collection",
4923 eImageInfo_GarbageCollected);
4924
4925 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
4926 // Add the ObjC GC Only value.
4927 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
4928 eImageInfo_GCOnly);
4929
4930 // Require that GC be specified and set to eImageInfo_GarbageCollected.
4931 llvm::Metadata *Ops[2] = {
4932 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
4933 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
4934 llvm::Type::getInt32Ty(VMContext), eImageInfo_GarbageCollected))};
4935 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
4936 llvm::MDNode::get(VMContext, Ops));
4937 }
4938 }
4939
4940 // Indicate whether we're compiling this to run on a simulator.
4941 if (CGM.getTarget().getTriple().isSimulatorEnvironment())
4942 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
4943 eImageInfo_ImageIsSimulated);
4944
4945 // Indicate whether we are generating class properties.
4946 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
4947 eImageInfo_ClassProperties);
4948 }
4949
4950 // struct objc_module {
4951 // unsigned long version;
4952 // unsigned long size;
4953 // const char *name;
4954 // Symtab symtab;
4955 // };
4956
4957 // FIXME: Get from somewhere
4958 static const int ModuleVersion = 7;
4959
4960 void CGObjCMac::EmitModuleInfo() {
4961 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
4962
4963 ConstantInitBuilder builder(CGM);
4964 auto values = builder.beginStruct(ObjCTypes.ModuleTy);
4965 values.addInt(ObjCTypes.LongTy, ModuleVersion);
4966 values.addInt(ObjCTypes.LongTy, Size);
4967 // This used to be the filename, now it is unused. <rdr://4327263>
4968 values.add(GetClassName(StringRef("")));
4969 values.add(EmitModuleSymbols());
4970 CreateMetadataVar("OBJC_MODULES", values,
4971 "__OBJC,__module_info,regular,no_dead_strip",
4972 CGM.getPointerAlign(), true);
4973 }
4974
4975 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
4976 unsigned NumClasses = DefinedClasses.size();
4977 unsigned NumCategories = DefinedCategories.size();
4978
4979 // Return null if no symbols were defined.
4980 if (!NumClasses && !NumCategories)
4981 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
4982
4983 ConstantInitBuilder builder(CGM);
4984 auto values = builder.beginStruct();
4985 values.addInt(ObjCTypes.LongTy, 0);
4986 values.addNullPointer(ObjCTypes.SelectorPtrTy);
4987 values.addInt(ObjCTypes.ShortTy, NumClasses);
4988 values.addInt(ObjCTypes.ShortTy, NumCategories);
4989
4990 // The runtime expects exactly the list of defined classes followed
4991 // by the list of defined categories, in a single array.
4992 auto array = values.beginArray(ObjCTypes.Int8PtrTy);
4993 for (unsigned i=0; i<NumClasses; i++) {
4994 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
4995 assert(ID);
4996 if (ObjCImplementationDecl *IMP = ID->getImplementation())
4997 // We are implementing a weak imported interface. Give it external linkage
4998 if (ID->isWeakImported() && !IMP->isWeakImported())
4999 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5000
5001 array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
5002 }
5003 for (unsigned i=0; i<NumCategories; i++)
5004 array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
5005
5006 array.finishAndAddTo(values);
5007
5008 llvm::GlobalVariable *GV = CreateMetadataVar(
5009 "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
5010 CGM.getPointerAlign(), true);
5011 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
5012 }
5013
5014 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
5015 IdentifierInfo *II) {
5016 LazySymbols.insert(II);
5017
5018 llvm::GlobalVariable *&Entry = ClassReferences[II];
5019
5020 if (!Entry) {
5021 llvm::Constant *Casted =
5022 llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
5023 ObjCTypes.ClassPtrTy);
5024 Entry = CreateMetadataVar(
5025 "OBJC_CLASS_REFERENCES_", Casted,
5026 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
5027 CGM.getPointerAlign(), true);
5028 }
5029
5030 return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
5031 }
5032
5033 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
5034 const ObjCInterfaceDecl *ID) {
5035 // If the class has the objc_runtime_visible attribute, we need to
5036 // use the Objective-C runtime to get the class.
5037 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
5038 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
5039
5040 IdentifierInfo *RuntimeName =
5041 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
5042 return EmitClassRefFromId(CGF, RuntimeName);
5043 }
5044
5045 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
5046 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
5047 return EmitClassRefFromId(CGF, II);
5048 }
5049
5050 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
5051 return CGF.Builder.CreateLoad(EmitSelectorAddr(CGF, Sel));
5052 }
5053
5054 Address CGObjCMac::EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel) {
5055 CharUnits Align = CGF.getPointerAlign();
5056
5057 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5058 if (!Entry) {
5059 llvm::Constant *Casted =
5060 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5061 ObjCTypes.SelectorPtrTy);
5062 Entry = CreateMetadataVar(
5063 "OBJC_SELECTOR_REFERENCES_", Casted,
5064 "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5065 Entry->setExternallyInitialized(true);
5066 }
5067
5068 return Address(Entry, Align);
5069 }
5070
5071 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5072 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5073 if (!Entry)
5074 Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5075 return getConstantGEP(VMContext, Entry, 0, 0);
5076 }
5077
5078 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5079 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5080 I = MethodDefinitions.find(MD);
5081 if (I != MethodDefinitions.end())
5082 return I->second;
5083
5084 return nullptr;
5085 }
5086
5087 /// GetIvarLayoutName - Returns a unique constant for the given
5088 /// ivar layout bitmap.
5089 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5090 const ObjCCommonTypesHelper &ObjCTypes) {
5091 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5092 }
5093
5094 void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5095 CharUnits offset) {
5096 const RecordDecl *RD = RT->getDecl();
5097
5098 // If this is a union, remember that we had one, because it might mess
5099 // up the ordering of layout entries.
5100 if (RD->isUnion())
5101 IsDisordered = true;
5102
5103 const ASTRecordLayout *recLayout = nullptr;
5104 visitAggregate(RD->field_begin(), RD->field_end(), offset,
5105 [&](const FieldDecl *field) -> CharUnits {
5106 if (!recLayout)
5107 recLayout = &CGM.getContext().getASTRecordLayout(RD);
5108 auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5109 return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5110 });
5111 }
5112
5113 template <class Iterator, class GetOffsetFn>
5114 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5115 CharUnits aggregateOffset,
5116 const GetOffsetFn &getOffset) {
5117 for (; begin != end; ++begin) {
5118 auto field = *begin;
5119
5120 // Skip over bitfields.
5121 if (field->isBitField()) {
5122 continue;
5123 }
5124
5125 // Compute the offset of the field within the aggregate.
5126 CharUnits fieldOffset = aggregateOffset + getOffset(field);
5127
5128 visitField(field, fieldOffset);
5129 }
5130 }
5131
5132 /// Collect layout information for the given fields into IvarsInfo.
5133 void IvarLayoutBuilder::visitField(const FieldDecl *field,
5134 CharUnits fieldOffset) {
5135 QualType fieldType = field->getType();
5136
5137 // Drill down into arrays.
5138 uint64_t numElts = 1;
5139 if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5140 numElts = 0;
5141 fieldType = arrayType->getElementType();
5142 }
5143 // Unlike incomplete arrays, constant arrays can be nested.
5144 while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5145 numElts *= arrayType->getSize().getZExtValue();
5146 fieldType = arrayType->getElementType();
5147 }
5148
5149 assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
5150
5151 // If we ended up with a zero-sized array, we've done what we can do within
5152 // the limits of this layout encoding.
5153 if (numElts == 0) return;
5154
5155 // Recurse if the base element type is a record type.
5156 if (auto recType = fieldType->getAs<RecordType>()) {
5157 size_t oldEnd = IvarsInfo.size();
5158
5159 visitRecord(recType, fieldOffset);
5160
5161 // If we have an array, replicate the first entry's layout information.
5162 auto numEltEntries = IvarsInfo.size() - oldEnd;
5163 if (numElts != 1 && numEltEntries != 0) {
5164 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5165 for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5166 // Copy the last numEltEntries onto the end of the array, adjusting
5167 // each for the element size.
5168 for (size_t i = 0; i != numEltEntries; ++i) {
5169 auto firstEntry = IvarsInfo[oldEnd + i];
5170 IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5171 firstEntry.SizeInWords));
5172 }
5173 }
5174 }
5175
5176 return;
5177 }
5178
5179 // Classify the element type.
5180 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5181
5182 // If it matches what we're looking for, add an entry.
5183 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5184 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5185 assert(CGM.getContext().getTypeSizeInChars(fieldType)
5186 == CGM.getPointerSize());
5187 IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5188 }
5189 }
5190
5191 /// buildBitmap - This routine does the horsework of taking the offsets of
5192 /// strong/weak references and creating a bitmap. The bitmap is also
5193 /// returned in the given buffer, suitable for being passed to \c dump().
5194 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5195 llvm::SmallVectorImpl<unsigned char> &buffer) {
5196 // The bitmap is a series of skip/scan instructions, aligned to word
5197 // boundaries. The skip is performed first.
5198 const unsigned char MaxNibble = 0xF;
5199 const unsigned char SkipMask = 0xF0, SkipShift = 4;
5200 const unsigned char ScanMask = 0x0F, ScanShift = 0;
5201
5202 assert(!IvarsInfo.empty() && "generating bitmap for no data");
5203
5204 // Sort the ivar info on byte position in case we encounterred a
5205 // union nested in the ivar list.
5206 if (IsDisordered) {
5207 // This isn't a stable sort, but our algorithm should handle it fine.
5208 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5209 } else {
5210 assert(std::is_sorted(IvarsInfo.begin(), IvarsInfo.end()));
5211 }
5212 assert(IvarsInfo.back().Offset < InstanceEnd);
5213
5214 assert(buffer.empty());
5215
5216 // Skip the next N words.
5217 auto skip = [&](unsigned numWords) {
5218 assert(numWords > 0);
5219
5220 // Try to merge into the previous byte. Since scans happen second, we
5221 // can't do this if it includes a scan.
5222 if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5223 unsigned lastSkip = buffer.back() >> SkipShift;
5224 if (lastSkip < MaxNibble) {
5225 unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5226 numWords -= claimed;
5227 lastSkip += claimed;
5228 buffer.back() = (lastSkip << SkipShift);
5229 }
5230 }
5231
5232 while (numWords >= MaxNibble) {
5233 buffer.push_back(MaxNibble << SkipShift);
5234 numWords -= MaxNibble;
5235 }
5236 if (numWords) {
5237 buffer.push_back(numWords << SkipShift);
5238 }
5239 };
5240
5241 // Scan the next N words.
5242 auto scan = [&](unsigned numWords) {
5243 assert(numWords > 0);
5244
5245 // Try to merge into the previous byte. Since scans happen second, we can
5246 // do this even if it includes a skip.
5247 if (!buffer.empty()) {
5248 unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5249 if (lastScan < MaxNibble) {
5250 unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5251 numWords -= claimed;
5252 lastScan += claimed;
5253 buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5254 }
5255 }
5256
5257 while (numWords >= MaxNibble) {
5258 buffer.push_back(MaxNibble << ScanShift);
5259 numWords -= MaxNibble;
5260 }
5261 if (numWords) {
5262 buffer.push_back(numWords << ScanShift);
5263 }
5264 };
5265
5266 // One past the end of the last scan.
5267 unsigned endOfLastScanInWords = 0;
5268 const CharUnits WordSize = CGM.getPointerSize();
5269
5270 // Consider all the scan requests.
5271 for (auto &request : IvarsInfo) {
5272 CharUnits beginOfScan = request.Offset - InstanceBegin;
5273
5274 // Ignore scan requests that don't start at an even multiple of the
5275 // word size. We can't encode them.
5276 if ((beginOfScan % WordSize) != 0) continue;
5277
5278 // Ignore scan requests that start before the instance start.
5279 // This assumes that scans never span that boundary. The boundary
5280 // isn't the true start of the ivars, because in the fragile-ARC case
5281 // it's rounded up to word alignment, but the test above should leave
5282 // us ignoring that possibility.
5283 if (beginOfScan.isNegative()) {
5284 assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
5285 continue;
5286 }
5287
5288 unsigned beginOfScanInWords = beginOfScan / WordSize;
5289 unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5290
5291 // If the scan starts some number of words after the last one ended,
5292 // skip forward.
5293 if (beginOfScanInWords > endOfLastScanInWords) {
5294 skip(beginOfScanInWords - endOfLastScanInWords);
5295
5296 // Otherwise, start scanning where the last left off.
5297 } else {
5298 beginOfScanInWords = endOfLastScanInWords;
5299
5300 // If that leaves us with nothing to scan, ignore this request.
5301 if (beginOfScanInWords >= endOfScanInWords) continue;
5302 }
5303
5304 // Scan to the end of the request.
5305 assert(beginOfScanInWords < endOfScanInWords);
5306 scan(endOfScanInWords - beginOfScanInWords);
5307 endOfLastScanInWords = endOfScanInWords;
5308 }
5309
5310 if (buffer.empty())
5311 return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5312
5313 // For GC layouts, emit a skip to the end of the allocation so that we
5314 // have precise information about the entire thing. This isn't useful
5315 // or necessary for the ARC-style layout strings.
5316 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5317 unsigned lastOffsetInWords =
5318 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5319 if (lastOffsetInWords > endOfLastScanInWords) {
5320 skip(lastOffsetInWords - endOfLastScanInWords);
5321 }
5322 }
5323
5324 // Null terminate the string.
5325 buffer.push_back(0);
5326
5327 auto *Entry = CGObjC.CreateCStringLiteral(
5328 reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5329 return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5330 }
5331
5332 /// BuildIvarLayout - Builds ivar layout bitmap for the class
5333 /// implementation for the __strong or __weak case.
5334 /// The layout map displays which words in ivar list must be skipped
5335 /// and which must be scanned by GC (see below). String is built of bytes.
5336 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5337 /// of words to skip and right nibble is count of words to scan. So, each
5338 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5339 /// represented by a 0x00 byte which also ends the string.
5340 /// 1. when ForStrongLayout is true, following ivars are scanned:
5341 /// - id, Class
5342 /// - object *
5343 /// - __strong anything
5344 ///
5345 /// 2. When ForStrongLayout is false, following ivars are scanned:
5346 /// - __weak anything
5347 ///
5348 llvm::Constant *
5349 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5350 CharUnits beginOffset, CharUnits endOffset,
5351 bool ForStrongLayout, bool HasMRCWeakIvars) {
5352 // If this is MRC, and we're either building a strong layout or there
5353 // are no weak ivars, bail out early.
5354 llvm::Type *PtrTy = CGM.Int8PtrTy;
5355 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5356 !CGM.getLangOpts().ObjCAutoRefCount &&
5357 (ForStrongLayout || !HasMRCWeakIvars))
5358 return llvm::Constant::getNullValue(PtrTy);
5359
5360 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5361 SmallVector<const ObjCIvarDecl*, 32> ivars;
5362
5363 // GC layout strings include the complete object layout, possibly
5364 // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5365 // up.
5366 //
5367 // ARC layout strings only include the class's ivars. In non-fragile
5368 // runtimes, that means starting at InstanceStart, rounded up to word
5369 // alignment. In fragile runtimes, there's no InstanceStart, so it means
5370 // starting at the offset of the first ivar, rounded up to word alignment.
5371 //
5372 // MRC weak layout strings follow the ARC style.
5373 CharUnits baseOffset;
5374 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5375 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5376 IVD; IVD = IVD->getNextIvar())
5377 ivars.push_back(IVD);
5378
5379 if (isNonFragileABI()) {
5380 baseOffset = beginOffset; // InstanceStart
5381 } else if (!ivars.empty()) {
5382 baseOffset =
5383 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5384 } else {
5385 baseOffset = CharUnits::Zero();
5386 }
5387
5388 baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5389 }
5390 else {
5391 CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5392
5393 baseOffset = CharUnits::Zero();
5394 }
5395
5396 if (ivars.empty())
5397 return llvm::Constant::getNullValue(PtrTy);
5398
5399 IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5400
5401 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5402 [&](const ObjCIvarDecl *ivar) -> CharUnits {
5403 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5404 });
5405
5406 if (!builder.hasBitmapData())
5407 return llvm::Constant::getNullValue(PtrTy);
5408
5409 llvm::SmallVector<unsigned char, 4> buffer;
5410 llvm::Constant *C = builder.buildBitmap(*this, buffer);
5411
5412 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5413 printf("\n%s ivar layout for class '%s': ",
5414 ForStrongLayout ? "strong" : "weak",
5415 OMD->getClassInterface()->getName().str().c_str());
5416 builder.dump(buffer);
5417 }
5418 return C;
5419 }
5420
5421 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5422 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5423 // FIXME: Avoid std::string in "Sel.getAsString()"
5424 if (!Entry)
5425 Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5426 return getConstantGEP(VMContext, Entry, 0, 0);
5427 }
5428
5429 // FIXME: Merge into a single cstring creation function.
5430 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5431 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5432 }
5433
5434 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5435 std::string TypeStr;
5436 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5437
5438 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5439 if (!Entry)
5440 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5441 return getConstantGEP(VMContext, Entry, 0, 0);
5442 }
5443
5444 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5445 bool Extended) {
5446 std::string TypeStr =
5447 CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5448
5449 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5450 if (!Entry)
5451 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5452 return getConstantGEP(VMContext, Entry, 0, 0);
5453 }
5454
5455 // FIXME: Merge into a single cstring creation function.
5456 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5457 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5458 if (!Entry)
5459 Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5460 return getConstantGEP(VMContext, Entry, 0, 0);
5461 }
5462
5463 // FIXME: Merge into a single cstring creation function.
5464 // FIXME: This Decl should be more precise.
5465 llvm::Constant *
5466 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5467 const Decl *Container) {
5468 std::string TypeStr =
5469 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5470 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5471 }
5472
5473 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
5474 const ObjCContainerDecl *CD,
5475 SmallVectorImpl<char> &Name) {
5476 llvm::raw_svector_ostream OS(Name);
5477 assert (CD && "Missing container decl in GetNameForMethod");
5478 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
5479 << '[' << CD->getName();
5480 if (const ObjCCategoryImplDecl *CID =
5481 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
5482 OS << '(' << *CID << ')';
5483 OS << ' ' << D->getSelector().getAsString() << ']';
5484 }
5485
5486 void CGObjCMac::FinishModule() {
5487 EmitModuleInfo();
5488
5489 // Emit the dummy bodies for any protocols which were referenced but
5490 // never defined.
5491 for (auto &entry : Protocols) {
5492 llvm::GlobalVariable *global = entry.second;
5493 if (global->hasInitializer())
5494 continue;
5495
5496 ConstantInitBuilder builder(CGM);
5497 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5498 values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5499 values.add(GetClassName(entry.first->getName()));
5500 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5501 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5502 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5503 values.finishAndSetAsInitializer(global);
5504 CGM.addCompilerUsedGlobal(global);
5505 }
5506
5507 // Add assembler directives to add lazy undefined symbol references
5508 // for classes which are referenced but not defined. This is
5509 // important for correct linker interaction.
5510 //
5511 // FIXME: It would be nice if we had an LLVM construct for this.
5512 if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5513 CGM.getTriple().isOSBinFormatMachO()) {
5514 SmallString<256> Asm;
5515 Asm += CGM.getModule().getModuleInlineAsm();
5516 if (!Asm.empty() && Asm.back() != '\n')
5517 Asm += '\n';
5518
5519 llvm::raw_svector_ostream OS(Asm);
5520 for (const auto *Sym : DefinedSymbols)
5521 OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5522 << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5523 for (const auto *Sym : LazySymbols)
5524 OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5525 for (const auto &Category : DefinedCategoryNames)
5526 OS << "\t.objc_category_name_" << Category << "=0\n"
5527 << "\t.globl .objc_category_name_" << Category << "\n";
5528
5529 CGM.getModule().setModuleInlineAsm(OS.str());
5530 }
5531 }
5532
5533 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5534 : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5535 ObjCEmptyVtableVar(nullptr) {
5536 ObjCABI = 2;
5537 }
5538
5539 /* *** */
5540
5541 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5542 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5543 {
5544 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5545 ASTContext &Ctx = CGM.getContext();
5546
5547 ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5548 IntTy = CGM.IntTy;
5549 LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5550 Int8PtrTy = CGM.Int8PtrTy;
5551 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5552
5553 // arm64 targets use "int" ivar offset variables. All others,
5554 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5555 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5556 IvarOffsetVarTy = IntTy;
5557 else
5558 IvarOffsetVarTy = LongTy;
5559
5560 ObjectPtrTy =
5561 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5562 PtrObjectPtrTy =
5563 llvm::PointerType::getUnqual(ObjectPtrTy);
5564 SelectorPtrTy =
5565 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5566
5567 // I'm not sure I like this. The implicit coordination is a bit
5568 // gross. We should solve this in a reasonable fashion because this
5569 // is a pretty common task (match some runtime data structure with
5570 // an LLVM data structure).
5571
5572 // FIXME: This is leaked.
5573 // FIXME: Merge with rewriter code?
5574
5575 // struct _objc_super {
5576 // id self;
5577 // Class cls;
5578 // }
5579 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5580 Ctx.getTranslationUnitDecl(),
5581 SourceLocation(), SourceLocation(),
5582 &Ctx.Idents.get("_objc_super"));
5583 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5584 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5585 false, ICIS_NoInit));
5586 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5587 nullptr, Ctx.getObjCClassType(), nullptr,
5588 nullptr, false, ICIS_NoInit));
5589 RD->completeDefinition();
5590
5591 SuperCTy = Ctx.getTagDeclType(RD);
5592 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5593
5594 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5595 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5596
5597 // struct _prop_t {
5598 // char *name;
5599 // char *attributes;
5600 // }
5601 PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);
5602
5603 // struct _prop_list_t {
5604 // uint32_t entsize; // sizeof(struct _prop_t)
5605 // uint32_t count_of_properties;
5606 // struct _prop_t prop_list[count_of_properties];
5607 // }
5608 PropertyListTy = llvm::StructType::create(
5609 "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
5610 // struct _prop_list_t *
5611 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5612
5613 // struct _objc_method {
5614 // SEL _cmd;
5615 // char *method_type;
5616 // char *_imp;
5617 // }
5618 MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
5619 Int8PtrTy, Int8PtrTy);
5620
5621 // struct _objc_cache *
5622 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5623 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5624 }
5625
5626 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5627 : ObjCCommonTypesHelper(cgm) {
5628 // struct _objc_method_description {
5629 // SEL name;
5630 // char *types;
5631 // }
5632 MethodDescriptionTy = llvm::StructType::create(
5633 "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);
5634
5635 // struct _objc_method_description_list {
5636 // int count;
5637 // struct _objc_method_description[1];
5638 // }
5639 MethodDescriptionListTy =
5640 llvm::StructType::create("struct._objc_method_description_list", IntTy,
5641 llvm::ArrayType::get(MethodDescriptionTy, 0));
5642
5643 // struct _objc_method_description_list *
5644 MethodDescriptionListPtrTy =
5645 llvm::PointerType::getUnqual(MethodDescriptionListTy);
5646
5647 // Protocol description structures
5648
5649 // struct _objc_protocol_extension {
5650 // uint32_t size; // sizeof(struct _objc_protocol_extension)
5651 // struct _objc_method_description_list *optional_instance_methods;
5652 // struct _objc_method_description_list *optional_class_methods;
5653 // struct _objc_property_list *instance_properties;
5654 // const char ** extendedMethodTypes;
5655 // struct _objc_property_list *class_properties;
5656 // }
5657 ProtocolExtensionTy = llvm::StructType::create(
5658 "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
5659 MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
5660 PropertyListPtrTy);
5661
5662 // struct _objc_protocol_extension *
5663 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5664
5665 // Handle recursive construction of Protocol and ProtocolList types
5666
5667 ProtocolTy =
5668 llvm::StructType::create(VMContext, "struct._objc_protocol");
5669
5670 ProtocolListTy =
5671 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5672 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
5673 llvm::ArrayType::get(ProtocolTy, 0));
5674
5675 // struct _objc_protocol {
5676 // struct _objc_protocol_extension *isa;
5677 // char *protocol_name;
5678 // struct _objc_protocol **_objc_protocol_list;
5679 // struct _objc_method_description_list *instance_methods;
5680 // struct _objc_method_description_list *class_methods;
5681 // }
5682 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5683 llvm::PointerType::getUnqual(ProtocolListTy),
5684 MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);
5685
5686 // struct _objc_protocol_list *
5687 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5688
5689 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5690
5691 // Class description structures
5692
5693 // struct _objc_ivar {
5694 // char *ivar_name;
5695 // char *ivar_type;
5696 // int ivar_offset;
5697 // }
5698 IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
5699 IntTy);
5700
5701 // struct _objc_ivar_list *
5702 IvarListTy =
5703 llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5704 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5705
5706 // struct _objc_method_list *
5707 MethodListTy =
5708 llvm::StructType::create(VMContext, "struct._objc_method_list");
5709 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5710
5711 // struct _objc_class_extension *
5712 ClassExtensionTy = llvm::StructType::create(
5713 "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
5714 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5715
5716 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5717
5718 // struct _objc_class {
5719 // Class isa;
5720 // Class super_class;
5721 // char *name;
5722 // long version;
5723 // long info;
5724 // long instance_size;
5725 // struct _objc_ivar_list *ivars;
5726 // struct _objc_method_list *methods;
5727 // struct _objc_cache *cache;
5728 // struct _objc_protocol_list *protocols;
5729 // char *ivar_layout;
5730 // struct _objc_class_ext *ext;
5731 // };
5732 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5733 llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
5734 LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
5735 ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);
5736
5737 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5738
5739 // struct _objc_category {
5740 // char *category_name;
5741 // char *class_name;
5742 // struct _objc_method_list *instance_method;
5743 // struct _objc_method_list *class_method;
5744 // struct _objc_protocol_list *protocols;
5745 // uint32_t size; // sizeof(struct _objc_category)
5746 // struct _objc_property_list *instance_properties;// category's @property
5747 // struct _objc_property_list *class_properties;
5748 // }
5749 CategoryTy = llvm::StructType::create(
5750 "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5751 MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
5752 PropertyListPtrTy);
5753
5754 // Global metadata structures
5755
5756 // struct _objc_symtab {
5757 // long sel_ref_cnt;
5758 // SEL *refs;
5759 // short cls_def_cnt;
5760 // short cat_def_cnt;
5761 // char *defs[cls_def_cnt + cat_def_cnt];
5762 // }
5763 SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
5764 SelectorPtrTy, ShortTy, ShortTy,
5765 llvm::ArrayType::get(Int8PtrTy, 0));
5766 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5767
5768 // struct _objc_module {
5769 // long version;
5770 // long size; // sizeof(struct _objc_module)
5771 // char *name;
5772 // struct _objc_symtab* symtab;
5773 // }
5774 ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
5775 Int8PtrTy, SymtabPtrTy);
5776
5777 // FIXME: This is the size of the setjmp buffer and should be target
5778 // specific. 18 is what's used on 32-bit X86.
5779 uint64_t SetJmpBufferSize = 18;
5780
5781 // Exceptions
5782 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5783
5784 ExceptionDataTy = llvm::StructType::create(
5785 "struct._objc_exception_data",
5786 llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
5787 }
5788
5789 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
5790 : ObjCCommonTypesHelper(cgm) {
5791 // struct _method_list_t {
5792 // uint32_t entsize; // sizeof(struct _objc_method)
5793 // uint32_t method_count;
5794 // struct _objc_method method_list[method_count];
5795 // }
5796 MethodListnfABITy =
5797 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
5798 llvm::ArrayType::get(MethodTy, 0));
5799 // struct method_list_t *
5800 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
5801
5802 // struct _protocol_t {
5803 // id isa; // NULL
5804 // const char * const protocol_name;
5805 // const struct _protocol_list_t * protocol_list; // super protocols
5806 // const struct method_list_t * const instance_methods;
5807 // const struct method_list_t * const class_methods;
5808 // const struct method_list_t *optionalInstanceMethods;
5809 // const struct method_list_t *optionalClassMethods;
5810 // const struct _prop_list_t * properties;
5811 // const uint32_t size; // sizeof(struct _protocol_t)
5812 // const uint32_t flags; // = 0
5813 // const char ** extendedMethodTypes;
5814 // const char *demangledName;
5815 // const struct _prop_list_t * class_properties;
5816 // }
5817
5818 // Holder for struct _protocol_list_t *
5819 ProtocolListnfABITy =
5820 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5821
5822 ProtocolnfABITy = llvm::StructType::create(
5823 "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
5824 llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
5825 MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5826 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
5827 PropertyListPtrTy);
5828
5829 // struct _protocol_t*
5830 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
5831
5832 // struct _protocol_list_t {
5833 // long protocol_count; // Note, this is 32/64 bit
5834 // struct _protocol_t *[protocol_count];
5835 // }
5836 ProtocolListnfABITy->setBody(LongTy,
5837 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));
5838
5839 // struct _objc_protocol_list*
5840 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
5841
5842 // struct _ivar_t {
5843 // unsigned [long] int *offset; // pointer to ivar offset location
5844 // char *name;
5845 // char *type;
5846 // uint32_t alignment;
5847 // uint32_t size;
5848 // }
5849 IvarnfABITy = llvm::StructType::create(
5850 "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
5851 Int8PtrTy, Int8PtrTy, IntTy, IntTy);
5852
5853 // struct _ivar_list_t {
5854 // uint32 entsize; // sizeof(struct _ivar_t)
5855 // uint32 count;
5856 // struct _iver_t list[count];
5857 // }
5858 IvarListnfABITy =
5859 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
5860 llvm::ArrayType::get(IvarnfABITy, 0));
5861
5862 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
5863
5864 // struct _class_ro_t {
5865 // uint32_t const flags;
5866 // uint32_t const instanceStart;
5867 // uint32_t const instanceSize;
5868 // uint32_t const reserved; // only when building for 64bit targets
5869 // const uint8_t * const ivarLayout;
5870 // const char *const name;
5871 // const struct _method_list_t * const baseMethods;
5872 // const struct _objc_protocol_list *const baseProtocols;
5873 // const struct _ivar_list_t *const ivars;
5874 // const uint8_t * const weakIvarLayout;
5875 // const struct _prop_list_t * const properties;
5876 // }
5877
5878 // FIXME. Add 'reserved' field in 64bit abi mode!
5879 ClassRonfABITy = llvm::StructType::create(
5880 "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy,
5881 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy,
5882 Int8PtrTy, PropertyListPtrTy);
5883
5884 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
5885 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
5886 ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
5887 ->getPointerTo();
5888
5889 // struct _class_t {
5890 // struct _class_t *isa;
5891 // struct _class_t * const superclass;
5892 // void *cache;
5893 // IMP *vtable;
5894 // struct class_ro_t *ro;
5895 // }
5896
5897 ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
5898 ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
5899 llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
5900 llvm::PointerType::getUnqual(ImpnfABITy),
5901 llvm::PointerType::getUnqual(ClassRonfABITy));
5902
5903 // LLVM for struct _class_t *
5904 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
5905
5906 // struct _category_t {
5907 // const char * const name;
5908 // struct _class_t *const cls;
5909 // const struct _method_list_t * const instance_methods;
5910 // const struct _method_list_t * const class_methods;
5911 // const struct _protocol_list_t * const protocols;
5912 // const struct _prop_list_t * const properties;
5913 // const struct _prop_list_t * const class_properties;
5914 // const uint32_t size;
5915 // }
5916 CategorynfABITy = llvm::StructType::create(
5917 "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy,
5918 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy,
5919 PropertyListPtrTy, IntTy);
5920
5921 // New types for nonfragile abi messaging.
5922 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5923 ASTContext &Ctx = CGM.getContext();
5924
5925 // MessageRefTy - LLVM for:
5926 // struct _message_ref_t {
5927 // IMP messenger;
5928 // SEL name;
5929 // };
5930
5931 // First the clang type for struct _message_ref_t
5932 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5933 Ctx.getTranslationUnitDecl(),
5934 SourceLocation(), SourceLocation(),
5935 &Ctx.Idents.get("_message_ref_t"));
5936 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5937 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
5938 ICIS_NoInit));
5939 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5940 nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
5941 false, ICIS_NoInit));
5942 RD->completeDefinition();
5943
5944 MessageRefCTy = Ctx.getTagDeclType(RD);
5945 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
5946 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
5947
5948 // MessageRefPtrTy - LLVM for struct _message_ref_t*
5949 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
5950
5951 // SuperMessageRefTy - LLVM for:
5952 // struct _super_message_ref_t {
5953 // SUPER_IMP messenger;
5954 // SEL name;
5955 // };
5956 SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t",
5957 ImpnfABITy, SelectorPtrTy);
5958
5959 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
5960 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
5961
5962
5963 // struct objc_typeinfo {
5964 // const void** vtable; // objc_ehtype_vtable + 2
5965 // const char* name; // c++ typeinfo string
5966 // Class cls;
5967 // };
5968 EHTypeTy = llvm::StructType::create("struct._objc_typeinfo",
5969 llvm::PointerType::getUnqual(Int8PtrTy),
5970 Int8PtrTy, ClassnfABIPtrTy);
5971 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
5972 }
5973
5974 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
5975 FinishNonFragileABIModule();
5976
5977 return nullptr;
5978 }
5979
5980 void CGObjCNonFragileABIMac::AddModuleClassList(
5981 ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
5982 StringRef SectionName) {
5983 unsigned NumClasses = Container.size();
5984
5985 if (!NumClasses)
5986 return;
5987
5988 SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
5989 for (unsigned i=0; i<NumClasses; i++)
5990 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
5991 ObjCTypes.Int8PtrTy);
5992 llvm::Constant *Init =
5993 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
5994 Symbols.size()),
5995 Symbols);
5996
5997 llvm::GlobalVariable *GV =
5998 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
5999 llvm::GlobalValue::PrivateLinkage,
6000 Init,
6001 SymbolName);
6002 GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6003 GV->setSection(SectionName);
6004 CGM.addCompilerUsedGlobal(GV);
6005 }
6006
6007 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
6008 // nonfragile abi has no module definition.
6009
6010 // Build list of all implemented class addresses in array
6011 // L_OBJC_LABEL_CLASS_$.
6012
6013 for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
6014 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
6015 assert(ID);
6016 if (ObjCImplementationDecl *IMP = ID->getImplementation())
6017 // We are implementing a weak imported interface. Give it external linkage
6018 if (ID->isWeakImported() && !IMP->isWeakImported()) {
6019 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6020 DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6021 }
6022 }
6023
6024 AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
6025 GetSectionName("__objc_classlist",
6026 "regular,no_dead_strip"));
6027
6028 AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
6029 GetSectionName("__objc_nlclslist",
6030 "regular,no_dead_strip"));
6031
6032 // Build list of all implemented category addresses in array
6033 // L_OBJC_LABEL_CATEGORY_$.
6034 AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
6035 GetSectionName("__objc_catlist",
6036 "regular,no_dead_strip"));
6037 AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
6038 GetSectionName("__objc_nlcatlist",
6039 "regular,no_dead_strip"));
6040
6041 EmitImageInfo();
6042 }
6043
6044 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
6045 /// VTableDispatchMethods; false otherwise. What this means is that
6046 /// except for the 19 selectors in the list, we generate 32bit-style
6047 /// message dispatch call for all the rest.
6048 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
6049 // At various points we've experimented with using vtable-based
6050 // dispatch for all methods.
6051 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
6052 case CodeGenOptions::Legacy:
6053 return false;
6054 case CodeGenOptions::NonLegacy:
6055 return true;
6056 case CodeGenOptions::Mixed:
6057 break;
6058 }
6059
6060 // If so, see whether this selector is in the white-list of things which must
6061 // use the new dispatch convention. We lazily build a dense set for this.
6062 if (VTableDispatchMethods.empty()) {
6063 VTableDispatchMethods.insert(GetNullarySelector("alloc"));
6064 VTableDispatchMethods.insert(GetNullarySelector("class"));
6065 VTableDispatchMethods.insert(GetNullarySelector("self"));
6066 VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
6067 VTableDispatchMethods.insert(GetNullarySelector("length"));
6068 VTableDispatchMethods.insert(GetNullarySelector("count"));
6069
6070 // These are vtable-based if GC is disabled.
6071 // Optimistically use vtable dispatch for hybrid compiles.
6072 if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
6073 VTableDispatchMethods.insert(GetNullarySelector("retain"));
6074 VTableDispatchMethods.insert(GetNullarySelector("release"));
6075 VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
6076 }
6077
6078 VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
6079 VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
6080 VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
6081 VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
6082 VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
6083 VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
6084 VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
6085
6086 // These are vtable-based if GC is enabled.
6087 // Optimistically use vtable dispatch for hybrid compiles.
6088 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
6089 VTableDispatchMethods.insert(GetNullarySelector("hash"));
6090 VTableDispatchMethods.insert(GetUnarySelector("addObject"));
6091
6092 // "countByEnumeratingWithState:objects:count"
6093 IdentifierInfo *KeyIdents[] = {
6094 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
6095 &CGM.getContext().Idents.get("objects"),
6096 &CGM.getContext().Idents.get("count")
6097 };
6098 VTableDispatchMethods.insert(
6099 CGM.getContext().Selectors.getSelector(3, KeyIdents));
6100 }
6101 }
6102
6103 return VTableDispatchMethods.count(Sel);
6104 }
6105
6106 /// BuildClassRoTInitializer - generate meta-data for:
6107 /// struct _class_ro_t {
6108 /// uint32_t const flags;
6109 /// uint32_t const instanceStart;
6110 /// uint32_t const instanceSize;
6111 /// uint32_t const reserved; // only when building for 64bit targets
6112 /// const uint8_t * const ivarLayout;
6113 /// const char *const name;
6114 /// const struct _method_list_t * const baseMethods;
6115 /// const struct _protocol_list_t *const baseProtocols;
6116 /// const struct _ivar_list_t *const ivars;
6117 /// const uint8_t * const weakIvarLayout;
6118 /// const struct _prop_list_t * const properties;
6119 /// }
6120 ///
6121 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
6122 unsigned flags,
6123 unsigned InstanceStart,
6124 unsigned InstanceSize,
6125 const ObjCImplementationDecl *ID) {
6126 std::string ClassName = ID->getObjCRuntimeNameAsString();
6127
6128 CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6129 CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6130
6131 bool hasMRCWeak = false;
6132 if (CGM.getLangOpts().ObjCAutoRefCount)
6133 flags |= NonFragileABI_Class_CompiledByARC;
6134 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
6135 flags |= NonFragileABI_Class_HasMRCWeakIvars;
6136
6137 ConstantInitBuilder builder(CGM);
6138 auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);
6139
6140 values.addInt(ObjCTypes.IntTy, flags);
6141 values.addInt(ObjCTypes.IntTy, InstanceStart);
6142 values.addInt(ObjCTypes.IntTy, InstanceSize);
6143 values.add((flags & NonFragileABI_Class_Meta)
6144 ? GetIvarLayoutName(nullptr, ObjCTypes)
6145 : BuildStrongIvarLayout(ID, beginInstance, endInstance));
6146 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
6147
6148 // const struct _method_list_t * const baseMethods;
6149 SmallVector<const ObjCMethodDecl*, 16> methods;
6150 if (flags & NonFragileABI_Class_Meta) {
6151 for (const auto *MD : ID->class_methods())
6152 methods.push_back(MD);
6153 } else {
6154 for (const auto *MD : ID->instance_methods())
6155 methods.push_back(MD);
6156
6157 for (const auto *PID : ID->property_impls()) {
6158 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
6159 ObjCPropertyDecl *PD = PID->getPropertyDecl();
6160
6161 if (auto MD = PD->getGetterMethodDecl())
6162 if (GetMethodDefinition(MD))
6163 methods.push_back(MD);
6164 if (auto MD = PD->getSetterMethodDecl())
6165 if (GetMethodDefinition(MD))
6166 methods.push_back(MD);
6167 }
6168 }
6169 }
6170
6171 values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
6172 (flags & NonFragileABI_Class_Meta)
6173 ? MethodListType::ClassMethods
6174 : MethodListType::InstanceMethods,
6175 methods));
6176
6177 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6178 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
6179 values.add(EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
6180 + OID->getObjCRuntimeNameAsString(),
6181 OID->all_referenced_protocol_begin(),
6182 OID->all_referenced_protocol_end()));
6183
6184 if (flags & NonFragileABI_Class_Meta) {
6185 values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
6186 values.add(GetIvarLayoutName(nullptr, ObjCTypes));
6187 values.add(EmitPropertyList(
6188 "\01l_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6189 ID, ID->getClassInterface(), ObjCTypes, true));
6190 } else {
6191 values.add(EmitIvarList(ID));
6192 values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
6193 values.add(EmitPropertyList(
6194 "\01l_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6195 ID, ID->getClassInterface(), ObjCTypes, false));
6196 }
6197
6198 llvm::SmallString<64> roLabel;
6199 llvm::raw_svector_ostream(roLabel)
6200 << ((flags & NonFragileABI_Class_Meta) ? "\01l_OBJC_METACLASS_RO_$_"
6201 : "\01l_OBJC_CLASS_RO_$_")
6202 << ClassName;
6203
6204 llvm::GlobalVariable *CLASS_RO_GV =
6205 values.finishAndCreateGlobal(roLabel, CGM.getPointerAlign(),
6206 /*constant*/ false,
6207 llvm::GlobalValue::PrivateLinkage);
6208 if (CGM.getTriple().isOSBinFormatMachO())
6209 CLASS_RO_GV->setSection("__DATA, __objc_const");
6210 return CLASS_RO_GV;
6211 }
6212
6213 /// Build the metaclass object for a class.
6214 ///
6215 /// struct _class_t {
6216 /// struct _class_t *isa;
6217 /// struct _class_t * const superclass;
6218 /// void *cache;
6219 /// IMP *vtable;
6220 /// struct class_ro_t *ro;
6221 /// }
6222 ///
6223 llvm::GlobalVariable *
6224 CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
6225 bool isMetaclass,
6226 llvm::Constant *IsAGV,
6227 llvm::Constant *SuperClassGV,
6228 llvm::Constant *ClassRoGV,
6229 bool HiddenVisibility) {
6230 ConstantInitBuilder builder(CGM);
6231 auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
6232 values.add(IsAGV);
6233 if (SuperClassGV) {
6234 values.add(SuperClassGV);
6235 } else {
6236 values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
6237 }
6238 values.add(ObjCEmptyCacheVar);
6239 values.add(ObjCEmptyVtableVar);
6240 values.add(ClassRoGV);
6241
6242 llvm::GlobalVariable *GV =
6243 cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
6244 values.finishAndSetAsInitializer(GV);
6245
6246 if (CGM.getTriple().isOSBinFormatMachO())
6247 GV->setSection("__DATA, __objc_data");
6248 GV->setAlignment(
6249 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
6250 if (!CGM.getTriple().isOSBinFormatCOFF())
6251 if (HiddenVisibility)
6252 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6253 return GV;
6254 }
6255
6256 bool
6257 CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
6258 return OD->getClassMethod(GetNullarySelector("load")) != nullptr;
6259 }
6260
6261 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
6262 uint32_t &InstanceStart,
6263 uint32_t &InstanceSize) {
6264 const ASTRecordLayout &RL =
6265 CGM.getContext().getASTObjCImplementationLayout(OID);
6266
6267 // InstanceSize is really instance end.
6268 InstanceSize = RL.getDataSize().getQuantity();
6269
6270 // If there are no fields, the start is the same as the end.
6271 if (!RL.getFieldCount())
6272 InstanceStart = InstanceSize;
6273 else
6274 InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6275 }
6276
6277 static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
6278 StringRef Name) {
6279 IdentifierInfo &II = CGM.getContext().Idents.get(Name);
6280 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
6281 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
6282
6283 const VarDecl *VD = nullptr;
6284 for (const auto &Result : DC->lookup(&II))
6285 if ((VD = dyn_cast<VarDecl>(Result)))
6286 break;
6287
6288 if (!VD)
6289 return llvm::GlobalValue::DLLImportStorageClass;
6290 if (VD->hasAttr<DLLExportAttr>())
6291 return llvm::GlobalValue::DLLExportStorageClass;
6292 if (VD->hasAttr<DLLImportAttr>())
6293 return llvm::GlobalValue::DLLImportStorageClass;
6294 return llvm::GlobalValue::DefaultStorageClass;
6295 }
6296
6297 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
6298 if (!ObjCEmptyCacheVar) {
6299 ObjCEmptyCacheVar =
6300 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
6301 llvm::GlobalValue::ExternalLinkage, nullptr,
6302 "_objc_empty_cache");
6303 if (CGM.getTriple().isOSBinFormatCOFF())
6304 ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
6305
6306 // Only OS X with deployment version <10.9 use the empty vtable symbol
6307 const llvm::Triple &Triple = CGM.getTarget().getTriple();
6308 if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
6309 ObjCEmptyVtableVar =
6310 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
6311 llvm::GlobalValue::ExternalLinkage, nullptr,
6312 "_objc_empty_vtable");
6313 else
6314 ObjCEmptyVtableVar =
6315 llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
6316 }
6317
6318 // FIXME: Is this correct (that meta class size is never computed)?
6319 uint32_t InstanceStart =
6320 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6321 uint32_t InstanceSize = InstanceStart;
6322 uint32_t flags = NonFragileABI_Class_Meta;
6323
6324 llvm::Constant *SuperClassGV, *IsAGV;
6325
6326 const auto *CI = ID->getClassInterface();
6327 assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0");
6328
6329 // Build the flags for the metaclass.
6330 bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
6331 ? !CI->hasAttr<DLLExportAttr>()
6332 : CI->getVisibility() == HiddenVisibility;
6333 if (classIsHidden)
6334 flags |= NonFragileABI_Class_Hidden;
6335
6336 // FIXME: why is this flag set on the metaclass?
6337 // ObjC metaclasses have no fields and don't really get constructed.
6338 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6339 flags |= NonFragileABI_Class_HasCXXStructors;
6340 if (!ID->hasNonZeroConstructors())
6341 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6342 }
6343
6344 if (!CI->getSuperClass()) {
6345 // class is root
6346 flags |= NonFragileABI_Class_Root;
6347
6348 SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
6349 IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
6350 } else {
6351 // Has a root. Current class is not a root.
6352 const ObjCInterfaceDecl *Root = ID->getClassInterface();
6353 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6354 Root = Super;
6355
6356 const auto *Super = CI->getSuperClass();
6357 IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
6358 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
6359 }
6360
6361 llvm::GlobalVariable *CLASS_RO_GV =
6362 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6363
6364 llvm::GlobalVariable *MetaTClass =
6365 BuildClassObject(CI, /*metaclass*/ true,
6366 IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
6367 CGM.setGVProperties(MetaTClass, CI);
6368 DefinedMetaClasses.push_back(MetaTClass);
6369
6370 // Metadata for the class
6371 flags = 0;
6372 if (classIsHidden)
6373 flags |= NonFragileABI_Class_Hidden;
6374
6375 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6376 flags |= NonFragileABI_Class_HasCXXStructors;
6377
6378 // Set a flag to enable a runtime optimization when a class has
6379 // fields that require destruction but which don't require
6380 // anything except zero-initialization during construction. This
6381 // is most notably true of __strong and __weak types, but you can
6382 // also imagine there being C++ types with non-trivial default
6383 // constructors that merely set all fields to null.
6384 if (!ID->hasNonZeroConstructors())
6385 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6386 }
6387
6388 if (hasObjCExceptionAttribute(CGM.getContext(), CI))
6389 flags |= NonFragileABI_Class_Exception;
6390
6391 if (!CI->getSuperClass()) {
6392 flags |= NonFragileABI_Class_Root;
6393 SuperClassGV = nullptr;
6394 } else {
6395 // Has a root. Current class is not a root.
6396 const auto *Super = CI->getSuperClass();
6397 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
6398 }
6399
6400 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
6401 CLASS_RO_GV =
6402 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6403
6404 llvm::GlobalVariable *ClassMD =
6405 BuildClassObject(CI, /*metaclass*/ false,
6406 MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
6407 CGM.setGVProperties(ClassMD, CI);
6408 DefinedClasses.push_back(ClassMD);
6409 ImplementedClasses.push_back(CI);
6410
6411 // Determine if this class is also "non-lazy".
6412 if (ImplementationIsNonLazy(ID))
6413 DefinedNonLazyClasses.push_back(ClassMD);
6414
6415 // Force the definition of the EHType if necessary.
6416 if (flags & NonFragileABI_Class_Exception)
6417 (void) GetInterfaceEHType(CI, ForDefinition);
6418 // Make sure method definition entries are all clear for next implementation.
6419 MethodDefinitions.clear();
6420 }
6421
6422 /// GenerateProtocolRef - This routine is called to generate code for
6423 /// a protocol reference expression; as in:
6424 /// @code
6425 /// @protocol(Proto1);
6426 /// @endcode
6427 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6428 /// which will hold address of the protocol meta-data.
6429 ///
6430 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
6431 const ObjCProtocolDecl *PD) {
6432
6433 // This routine is called for @protocol only. So, we must build definition
6434 // of protocol's meta-data (not a reference to it!)
6435 //
6436 llvm::Constant *Init =
6437 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
6438 ObjCTypes.getExternalProtocolPtrTy());
6439
6440 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
6441 ProtocolName += PD->getObjCRuntimeNameAsString();
6442
6443 CharUnits Align = CGF.getPointerAlign();
6444
6445 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
6446 if (PTGV)
6447 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6448 PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6449 llvm::GlobalValue::WeakAnyLinkage, Init,
6450 ProtocolName);
6451 PTGV->setSection(GetSectionName("__objc_protorefs",
6452 "coalesced,no_dead_strip"));
6453 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6454 PTGV->setAlignment(Align.getQuantity());
6455 if (!CGM.getTriple().isOSBinFormatMachO())
6456 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName));
6457 CGM.addUsedGlobal(PTGV);
6458 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6459 }
6460
6461 /// GenerateCategory - Build metadata for a category implementation.
6462 /// struct _category_t {
6463 /// const char * const name;
6464 /// struct _class_t *const cls;
6465 /// const struct _method_list_t * const instance_methods;
6466 /// const struct _method_list_t * const class_methods;
6467 /// const struct _protocol_list_t * const protocols;
6468 /// const struct _prop_list_t * const properties;
6469 /// const struct _prop_list_t * const class_properties;
6470 /// const uint32_t size;
6471 /// }
6472 ///
6473 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
6474 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
6475 const char *Prefix = "\01l_OBJC_$_CATEGORY_";
6476
6477 llvm::SmallString<64> ExtCatName(Prefix);
6478 ExtCatName += Interface->getObjCRuntimeNameAsString();
6479 ExtCatName += "_$_";
6480 ExtCatName += OCD->getNameAsString();
6481
6482 ConstantInitBuilder builder(CGM);
6483 auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
6484 values.add(GetClassName(OCD->getIdentifier()->getName()));
6485 // meta-class entry symbol
6486 values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
6487 std::string listName =
6488 (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();
6489
6490 SmallVector<const ObjCMethodDecl *, 16> instanceMethods;
6491 SmallVector<const ObjCMethodDecl *, 8> classMethods;
6492 for (const auto *MD : OCD->methods()) {
6493 if (MD->isInstanceMethod()) {
6494 instanceMethods.push_back(MD);
6495 } else {
6496 classMethods.push_back(MD);
6497 }
6498 }
6499
6500 values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
6501 instanceMethods));
6502 values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
6503 classMethods));
6504
6505 const ObjCCategoryDecl *Category =
6506 Interface->FindCategoryDeclaration(OCD->getIdentifier());
6507 if (Category) {
6508 SmallString<256> ExtName;
6509 llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6510 << OCD->getName();
6511 values.add(EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
6512 + Interface->getObjCRuntimeNameAsString() + "_$_"
6513 + Category->getName(),
6514 Category->protocol_begin(),
6515 Category->protocol_end()));
6516 values.add(EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
6517 OCD, Category, ObjCTypes, false));
6518 values.add(EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
6519 OCD, Category, ObjCTypes, true));
6520 } else {
6521 values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
6522 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6523 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6524 }
6525
6526 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
6527 values.addInt(ObjCTypes.IntTy, Size);
6528
6529 llvm::GlobalVariable *GCATV =
6530 values.finishAndCreateGlobal(ExtCatName.str(), CGM.getPointerAlign(),
6531 /*constant*/ false,
6532 llvm::GlobalValue::PrivateLinkage);
6533 if (CGM.getTriple().isOSBinFormatMachO())
6534 GCATV->setSection("__DATA, __objc_const");
6535 CGM.addCompilerUsedGlobal(GCATV);
6536 DefinedCategories.push_back(GCATV);
6537
6538 // Determine if this category is also "non-lazy".
6539 if (ImplementationIsNonLazy(OCD))
6540 DefinedNonLazyCategories.push_back(GCATV);
6541 // method definition entries must be clear for next implementation.
6542 MethodDefinitions.clear();
6543 }
6544
6545 /// emitMethodConstant - Return a struct objc_method constant. If
6546 /// forProtocol is true, the implementation will be null; otherwise,
6547 /// the method must have a definition registered with the runtime.
6548 ///
6549 /// struct _objc_method {
6550 /// SEL _cmd;
6551 /// char *method_type;
6552 /// char *_imp;
6553 /// }
6554 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
6555 const ObjCMethodDecl *MD,
6556 bool forProtocol) {
6557 auto method = builder.beginStruct(ObjCTypes.MethodTy);
6558 method.addBitCast(GetMethodVarName(MD->getSelector()),
6559 ObjCTypes.SelectorPtrTy);
6560 method.add(GetMethodVarType(MD));
6561
6562 if (forProtocol) {
6563 // Protocol methods have no implementation. So, this entry is always NULL.
6564 method.addNullPointer(ObjCTypes.Int8PtrTy);
6565 } else {
6566 llvm::Function *fn = GetMethodDefinition(MD);
6567 assert(fn && "no definition for method?");
6568 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
6569 }
6570
6571 method.finishAndAddTo(builder);
6572 }
6573
6574 /// Build meta-data for method declarations.
6575 ///
6576 /// struct _method_list_t {
6577 /// uint32_t entsize; // sizeof(struct _objc_method)
6578 /// uint32_t method_count;
6579 /// struct _objc_method method_list[method_count];
6580 /// }
6581 ///
6582 llvm::Constant *
6583 CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
6584 ArrayRef<const ObjCMethodDecl *> methods) {
6585 // Return null for empty list.
6586 if (methods.empty())
6587 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6588
6589 StringRef prefix;
6590 bool forProtocol;
6591 switch (kind) {
6592 case MethodListType::CategoryInstanceMethods:
6593 prefix = "\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_";
6594 forProtocol = false;
6595 break;
6596 case MethodListType::CategoryClassMethods:
6597 prefix = "\01l_OBJC_$_CATEGORY_CLASS_METHODS_";
6598 forProtocol = false;
6599 break;
6600 case MethodListType::InstanceMethods:
6601 prefix = "\01l_OBJC_$_INSTANCE_METHODS_";
6602 forProtocol = false;
6603 break;
6604 case MethodListType::ClassMethods:
6605 prefix = "\01l_OBJC_$_CLASS_METHODS_";
6606 forProtocol = false;
6607 break;
6608
6609 case MethodListType::ProtocolInstanceMethods:
6610 prefix = "\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
6611 forProtocol = true;
6612 break;
6613 case MethodListType::ProtocolClassMethods:
6614 prefix = "\01l_OBJC_$_PROTOCOL_CLASS_METHODS_";
6615 forProtocol = true;
6616 break;
6617 case MethodListType::OptionalProtocolInstanceMethods:
6618 prefix = "\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
6619 forProtocol = true;
6620 break;
6621 case MethodListType::OptionalProtocolClassMethods:
6622 prefix = "\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
6623 forProtocol = true;
6624 break;
6625 }
6626
6627 ConstantInitBuilder builder(CGM);
6628 auto values = builder.beginStruct();
6629
6630 // sizeof(struct _objc_method)
6631 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6632 values.addInt(ObjCTypes.IntTy, Size);
6633 // method_count
6634 values.addInt(ObjCTypes.IntTy, methods.size());
6635 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
6636 for (auto MD : methods) {
6637 emitMethodConstant(methodArray, MD, forProtocol);
6638 }
6639 methodArray.finishAndAddTo(values);
6640
6641 auto *GV = values.finishAndCreateGlobal(prefix + name, CGM.getPointerAlign(),
6642 /*constant*/ false,
6643 llvm::GlobalValue::PrivateLinkage);
6644 if (CGM.getTriple().isOSBinFormatMachO())
6645 GV->setSection("__DATA, __objc_const");
6646 CGM.addCompilerUsedGlobal(GV);
6647 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6648 }
6649
6650 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6651 /// the given ivar.
6652 llvm::GlobalVariable *
6653 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6654 const ObjCIvarDecl *Ivar) {
6655 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6656 llvm::SmallString<64> Name("OBJC_IVAR_$_");
6657 Name += Container->getObjCRuntimeNameAsString();
6658 Name += ".";
6659 Name += Ivar->getName();
6660 llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
6661 if (!IvarOffsetGV) {
6662 IvarOffsetGV =
6663 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
6664 false, llvm::GlobalValue::ExternalLinkage,
6665 nullptr, Name.str());
6666 if (CGM.getTriple().isOSBinFormatCOFF()) {
6667 bool IsPrivateOrPackage =
6668 Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6669 Ivar->getAccessControl() == ObjCIvarDecl::Package;
6670
6671 const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface();
6672
6673 if (ContainingID->hasAttr<DLLImportAttr>())
6674 IvarOffsetGV
6675 ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6676 else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
6677 IvarOffsetGV
6678 ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6679 }
6680 }
6681 return IvarOffsetGV;
6682 }
6683
6684 llvm::Constant *
6685 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6686 const ObjCIvarDecl *Ivar,
6687 unsigned long int Offset) {
6688 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6689 IvarOffsetGV->setInitializer(
6690 llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6691 IvarOffsetGV->setAlignment(
6692 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy));
6693
6694 if (!CGM.getTriple().isOSBinFormatCOFF()) {
6695 // FIXME: This matches gcc, but shouldn't the visibility be set on the use
6696 // as well (i.e., in ObjCIvarOffsetVariable).
6697 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6698 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6699 ID->getVisibility() == HiddenVisibility)
6700 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6701 else
6702 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6703 }
6704
6705 if (CGM.getTriple().isOSBinFormatMachO())
6706 IvarOffsetGV->setSection("__DATA, __objc_ivar");
6707 return IvarOffsetGV;
6708 }
6709
6710 /// EmitIvarList - Emit the ivar list for the given
6711 /// implementation. The return value has type
6712 /// IvarListnfABIPtrTy.
6713 /// struct _ivar_t {
6714 /// unsigned [long] int *offset; // pointer to ivar offset location
6715 /// char *name;
6716 /// char *type;
6717 /// uint32_t alignment;
6718 /// uint32_t size;
6719 /// }
6720 /// struct _ivar_list_t {
6721 /// uint32 entsize; // sizeof(struct _ivar_t)
6722 /// uint32 count;
6723 /// struct _iver_t list[count];
6724 /// }
6725 ///
6726
6727 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6728 const ObjCImplementationDecl *ID) {
6729
6730 ConstantInitBuilder builder(CGM);
6731 auto ivarList = builder.beginStruct();
6732 ivarList.addInt(ObjCTypes.IntTy,
6733 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
6734 auto ivarCountSlot = ivarList.addPlaceholder();
6735 auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);
6736
6737 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6738 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6739
6740 // FIXME. Consolidate this with similar code in GenerateClass.
6741
6742 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6743 IVD; IVD = IVD->getNextIvar()) {
6744 // Ignore unnamed bit-fields.
6745 if (!IVD->getDeclName())
6746 continue;
6747
6748 auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
6749 ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6750 ComputeIvarBaseOffset(CGM, ID, IVD)));
6751 ivar.add(GetMethodVarName(IVD->getIdentifier()));
6752 ivar.add(GetMethodVarType(IVD));
6753 llvm::Type *FieldTy =
6754 CGM.getTypes().ConvertTypeForMem(IVD->getType());
6755 unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6756 unsigned Align = CGM.getContext().getPreferredTypeAlign(
6757 IVD->getType().getTypePtr()) >> 3;
6758 Align = llvm::Log2_32(Align);
6759 ivar.addInt(ObjCTypes.IntTy, Align);
6760 // NOTE. Size of a bitfield does not match gcc's, because of the
6761 // way bitfields are treated special in each. But I am told that
6762 // 'size' for bitfield ivars is ignored by the runtime so it does
6763 // not matter. If it matters, there is enough info to get the
6764 // bitfield right!
6765 ivar.addInt(ObjCTypes.IntTy, Size);
6766 ivar.finishAndAddTo(ivars);
6767 }
6768 // Return null for empty list.
6769 if (ivars.empty()) {
6770 ivars.abandon();
6771 ivarList.abandon();
6772 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
6773 }
6774
6775 auto ivarCount = ivars.size();
6776 ivars.finishAndAddTo(ivarList);
6777 ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);
6778
6779 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
6780 llvm::GlobalVariable *GV =
6781 ivarList.finishAndCreateGlobal(Prefix + OID->getObjCRuntimeNameAsString(),
6782 CGM.getPointerAlign(), /*constant*/ false,
6783 llvm::GlobalValue::PrivateLinkage);
6784 if (CGM.getTriple().isOSBinFormatMachO())
6785 GV->setSection("__DATA, __objc_const");
6786 CGM.addCompilerUsedGlobal(GV);
6787 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
6788 }
6789
6790 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
6791 const ObjCProtocolDecl *PD) {
6792 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
6793
6794 if (!Entry) {
6795 // We use the initializer as a marker of whether this is a forward
6796 // reference or not. At module finalization we add the empty
6797 // contents for protocols which were referenced but never defined.
6798 llvm::SmallString<64> Protocol;
6799 llvm::raw_svector_ostream(Protocol) << "\01l_OBJC_PROTOCOL_$_"
6800 << PD->getObjCRuntimeNameAsString();
6801
6802 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
6803 false, llvm::GlobalValue::ExternalLinkage,
6804 nullptr, Protocol);
6805 if (!CGM.getTriple().isOSBinFormatMachO())
6806 Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
6807 }
6808
6809 return Entry;
6810 }
6811
6812 /// GetOrEmitProtocol - Generate the protocol meta-data:
6813 /// @code
6814 /// struct _protocol_t {
6815 /// id isa; // NULL
6816 /// const char * const protocol_name;
6817 /// const struct _protocol_list_t * protocol_list; // super protocols
6818 /// const struct method_list_t * const instance_methods;
6819 /// const struct method_list_t * const class_methods;
6820 /// const struct method_list_t *optionalInstanceMethods;
6821 /// const struct method_list_t *optionalClassMethods;
6822 /// const struct _prop_list_t * properties;
6823 /// const uint32_t size; // sizeof(struct _protocol_t)
6824 /// const uint32_t flags; // = 0
6825 /// const char ** extendedMethodTypes;
6826 /// const char *demangledName;
6827 /// const struct _prop_list_t * class_properties;
6828 /// }
6829 /// @endcode
6830 ///
6831
6832 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
6833 const ObjCProtocolDecl *PD) {
6834 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
6835
6836 // Early exit if a defining object has already been generated.
6837 if (Entry && Entry->hasInitializer())
6838 return Entry;
6839
6840 // Use the protocol definition, if there is one.
6841 assert(PD->hasDefinition() &&
6842 "emitting protocol metadata without definition");
6843 PD = PD->getDefinition();
6844
6845 auto methodLists = ProtocolMethodLists::get(PD);
6846
6847 ConstantInitBuilder builder(CGM);
6848 auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
6849
6850 // isa is NULL
6851 values.addNullPointer(ObjCTypes.ObjectPtrTy);
6852 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
6853 values.add(EmitProtocolList("\01l_OBJC_$_PROTOCOL_REFS_"
6854 + PD->getObjCRuntimeNameAsString(),
6855 PD->protocol_begin(),
6856 PD->protocol_end()));
6857 values.add(methodLists.emitMethodList(this, PD,
6858 ProtocolMethodLists::RequiredInstanceMethods));
6859 values.add(methodLists.emitMethodList(this, PD,
6860 ProtocolMethodLists::RequiredClassMethods));
6861 values.add(methodLists.emitMethodList(this, PD,
6862 ProtocolMethodLists::OptionalInstanceMethods));
6863 values.add(methodLists.emitMethodList(this, PD,
6864 ProtocolMethodLists::OptionalClassMethods));
6865 values.add(EmitPropertyList(
6866 "\01l_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6867 nullptr, PD, ObjCTypes, false));
6868 uint32_t Size =
6869 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
6870 values.addInt(ObjCTypes.IntTy, Size);
6871 values.addInt(ObjCTypes.IntTy, 0);
6872 values.add(EmitProtocolMethodTypes("\01l_OBJC_$_PROTOCOL_METHOD_TYPES_"
6873 + PD->getObjCRuntimeNameAsString(),
6874 methodLists.emitExtendedTypesArray(this),
6875 ObjCTypes));
6876
6877 // const char *demangledName;
6878 values.addNullPointer(ObjCTypes.Int8PtrTy);
6879
6880 values.add(EmitPropertyList(
6881 "\01l_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6882 nullptr, PD, ObjCTypes, true));
6883
6884 if (Entry) {
6885 // Already created, fix the linkage and update the initializer.
6886 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
6887 values.finishAndSetAsInitializer(Entry);
6888 } else {
6889 llvm::SmallString<64> symbolName;
6890 llvm::raw_svector_ostream(symbolName)
6891 << "\01l_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();
6892
6893 Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
6894 /*constant*/ false,
6895 llvm::GlobalValue::WeakAnyLinkage);
6896 if (!CGM.getTriple().isOSBinFormatMachO())
6897 Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));
6898
6899 Protocols[PD->getIdentifier()] = Entry;
6900 }
6901 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
6902 CGM.addUsedGlobal(Entry);
6903
6904 // Use this protocol meta-data to build protocol list table in section
6905 // __DATA, __objc_protolist
6906 llvm::SmallString<64> ProtocolRef;
6907 llvm::raw_svector_ostream(ProtocolRef) << "\01l_OBJC_LABEL_PROTOCOL_$_"
6908 << PD->getObjCRuntimeNameAsString();
6909
6910 llvm::GlobalVariable *PTGV =
6911 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
6912 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
6913 ProtocolRef);
6914 if (!CGM.getTriple().isOSBinFormatMachO())
6915 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
6916 PTGV->setAlignment(
6917 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
6918 PTGV->setSection(GetSectionName("__objc_protolist",
6919 "coalesced,no_dead_strip"));
6920 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6921 CGM.addUsedGlobal(PTGV);
6922 return Entry;
6923 }
6924
6925 /// EmitProtocolList - Generate protocol list meta-data:
6926 /// @code
6927 /// struct _protocol_list_t {
6928 /// long protocol_count; // Note, this is 32/64 bit
6929 /// struct _protocol_t[protocol_count];
6930 /// }
6931 /// @endcode
6932 ///
6933 llvm::Constant *
6934 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
6935 ObjCProtocolDecl::protocol_iterator begin,
6936 ObjCProtocolDecl::protocol_iterator end) {
6937 SmallVector<llvm::Constant *, 16> ProtocolRefs;
6938
6939 // Just return null for empty protocol lists
6940 if (begin == end)
6941 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
6942
6943 // FIXME: We shouldn't need to do this lookup here, should we?
6944 SmallString<256> TmpName;
6945 Name.toVector(TmpName);
6946 llvm::GlobalVariable *GV =
6947 CGM.getModule().getGlobalVariable(TmpName.str(), true);
6948 if (GV)
6949 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
6950
6951 ConstantInitBuilder builder(CGM);
6952 auto values = builder.beginStruct();
6953 auto countSlot = values.addPlaceholder();
6954
6955 // A null-terminated array of protocols.
6956 auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
6957 for (; begin != end; ++begin)
6958 array.add(GetProtocolRef(*begin)); // Implemented???
6959 auto count = array.size();
6960 array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
6961
6962 array.finishAndAddTo(values);
6963 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
6964
6965 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
6966 /*constant*/ false,
6967 llvm::GlobalValue::PrivateLinkage);
6968 if (CGM.getTriple().isOSBinFormatMachO())
6969 GV->setSection("__DATA, __objc_const");
6970 CGM.addCompilerUsedGlobal(GV);
6971 return llvm::ConstantExpr::getBitCast(GV,
6972 ObjCTypes.ProtocolListnfABIPtrTy);
6973 }
6974
6975 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
6976 /// This code gen. amounts to generating code for:
6977 /// @code
6978 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
6979 /// @encode
6980 ///
6981 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
6982 CodeGen::CodeGenFunction &CGF,
6983 QualType ObjectTy,
6984 llvm::Value *BaseValue,
6985 const ObjCIvarDecl *Ivar,
6986 unsigned CVRQualifiers) {
6987 ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
6988 llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
6989 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
6990 Offset);
6991 }
6992
6993 llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
6994 CodeGen::CodeGenFunction &CGF,
6995 const ObjCInterfaceDecl *Interface,
6996 const ObjCIvarDecl *Ivar) {
6997 llvm::Value *IvarOffsetValue = ObjCIvarOffsetVariable(Interface, Ivar);
6998 IvarOffsetValue = CGF.Builder.CreateAlignedLoad(IvarOffsetValue,
6999 CGF.getSizeAlign(), "ivar");
7000 if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
7001 cast<llvm::LoadInst>(IvarOffsetValue)
7002 ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7003 llvm::MDNode::get(VMContext, None));
7004
7005 // This could be 32bit int or 64bit integer depending on the architecture.
7006 // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
7007 // as this is what caller always expects.
7008 if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
7009 IvarOffsetValue = CGF.Builder.CreateIntCast(
7010 IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
7011 return IvarOffsetValue;
7012 }
7013
7014 static void appendSelectorForMessageRefTable(std::string &buffer,
7015 Selector selector) {
7016 if (selector.isUnarySelector()) {
7017 buffer += selector.getNameForSlot(0);
7018 return;
7019 }
7020
7021 for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
7022 buffer += selector.getNameForSlot(i);
7023 buffer += '_';
7024 }
7025 }
7026
7027 /// Emit a "vtable" message send. We emit a weak hidden-visibility
7028 /// struct, initially containing the selector pointer and a pointer to
7029 /// a "fixup" variant of the appropriate objc_msgSend. To call, we
7030 /// load and call the function pointer, passing the address of the
7031 /// struct as the second parameter. The runtime determines whether
7032 /// the selector is currently emitted using vtable dispatch; if so, it
7033 /// substitutes a stub function which simply tail-calls through the
7034 /// appropriate vtable slot, and if not, it substitues a stub function
7035 /// which tail-calls objc_msgSend. Both stubs adjust the selector
7036 /// argument to correctly point to the selector.
7037 RValue
7038 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
7039 ReturnValueSlot returnSlot,
7040 QualType resultType,
7041 Selector selector,
7042 llvm::Value *arg0,
7043 QualType arg0Type,
7044 bool isSuper,
7045 const CallArgList &formalArgs,
7046 const ObjCMethodDecl *method) {
7047 // Compute the actual arguments.
7048 CallArgList args;
7049
7050 // First argument: the receiver / super-call structure.
7051 if (!isSuper)
7052 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
7053 args.add(RValue::get(arg0), arg0Type);
7054
7055 // Second argument: a pointer to the message ref structure. Leave
7056 // the actual argument value blank for now.
7057 args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7058
7059 args.insert(args.end(), formalArgs.begin(), formalArgs.end());
7060
7061 MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
7062
7063 NullReturnState nullReturn;
7064
7065 // Find the function to call and the mangled name for the message
7066 // ref structure. Using a different mangled name wouldn't actually
7067 // be a problem; it would just be a waste.
7068 //
7069 // The runtime currently never uses vtable dispatch for anything
7070 // except normal, non-super message-sends.
7071 // FIXME: don't use this for that.
7072 llvm::Constant *fn = nullptr;
7073 std::string messageRefName("\01l_");
7074 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
7075 if (isSuper) {
7076 fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
7077 messageRefName += "objc_msgSendSuper2_stret_fixup";
7078 } else {
7079 nullReturn.init(CGF, arg0);
7080 fn = ObjCTypes.getMessageSendStretFixupFn();
7081 messageRefName += "objc_msgSend_stret_fixup";
7082 }
7083 } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
7084 fn = ObjCTypes.getMessageSendFpretFixupFn();
7085 messageRefName += "objc_msgSend_fpret_fixup";
7086 } else {
7087 if (isSuper) {
7088 fn = ObjCTypes.getMessageSendSuper2FixupFn();
7089 messageRefName += "objc_msgSendSuper2_fixup";
7090 } else {
7091 fn = ObjCTypes.getMessageSendFixupFn();
7092 messageRefName += "objc_msgSend_fixup";
7093 }
7094 }
7095 assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
7096 messageRefName += '_';
7097
7098 // Append the selector name, except use underscores anywhere we
7099 // would have used colons.
7100 appendSelectorForMessageRefTable(messageRefName, selector);
7101
7102 llvm::GlobalVariable *messageRef
7103 = CGM.getModule().getGlobalVariable(messageRefName);
7104 if (!messageRef) {
7105 // Build the message ref structure.
7106 ConstantInitBuilder builder(CGM);
7107 auto values = builder.beginStruct();
7108 values.add(fn);
7109 values.add(GetMethodVarName(selector));
7110 messageRef = values.finishAndCreateGlobal(messageRefName,
7111 CharUnits::fromQuantity(16),
7112 /*constant*/ false,
7113 llvm::GlobalValue::WeakAnyLinkage);
7114 messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
7115 messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced"));
7116 }
7117
7118 bool requiresnullCheck = false;
7119 if (CGM.getLangOpts().ObjCAutoRefCount && method)
7120 for (const auto *ParamDecl : method->parameters()) {
7121 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
7122 if (!nullReturn.NullBB)
7123 nullReturn.init(CGF, arg0);
7124 requiresnullCheck = true;
7125 break;
7126 }
7127 }
7128
7129 Address mref =
7130 Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7131 CGF.getPointerAlign());
7132
7133 // Update the message ref argument.
7134 args[1].setRValue(RValue::get(mref.getPointer()));
7135
7136 // Load the function to call from the message ref table.
7137 Address calleeAddr =
7138 CGF.Builder.CreateStructGEP(mref, 0, CharUnits::Zero());
7139 llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7140
7141 calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7142 CGCallee callee(CGCalleeInfo(), calleePtr);
7143
7144 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7145 return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs,
7146 requiresnullCheck ? method : nullptr);
7147 }
7148
7149 /// Generate code for a message send expression in the nonfragile abi.
7150 CodeGen::RValue
7151 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
7152 ReturnValueSlot Return,
7153 QualType ResultType,
7154 Selector Sel,
7155 llvm::Value *Receiver,
7156 const CallArgList &CallArgs,
7157 const ObjCInterfaceDecl *Class,
7158 const ObjCMethodDecl *Method) {
7159 return isVTableDispatchedSelector(Sel)
7160 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7161 Receiver, CGF.getContext().getObjCIdType(),
7162 false, CallArgs, Method)
7163 : EmitMessageSend(CGF, Return, ResultType,
7164 EmitSelector(CGF, Sel),
7165 Receiver, CGF.getContext().getObjCIdType(),
7166 false, CallArgs, Method, Class, ObjCTypes);
7167 }
7168
7169 llvm::Constant *
7170 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
7171 bool metaclass,
7172 ForDefinition_t isForDefinition) {
7173 auto prefix =
7174 (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
7175 return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
7176 isForDefinition,
7177 ID->isWeakImported(),
7178 !isForDefinition
7179 && CGM.getTriple().isOSBinFormatCOFF()
7180 && ID->hasAttr<DLLImportAttr>());
7181 }
7182
7183 llvm::Constant *
7184 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
7185 ForDefinition_t IsForDefinition,
7186 bool Weak, bool DLLImport) {
7187 llvm::GlobalValue::LinkageTypes L =
7188 Weak ? llvm::GlobalValue::ExternalWeakLinkage
7189 : llvm::GlobalValue::ExternalLinkage;
7190
7191 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
7192 if (!GV || GV->getType() != ObjCTypes.ClassnfABITy->getPointerTo()) {
7193 auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L,
7194 nullptr, Name);
7195
7196 if (DLLImport)
7197 NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7198
7199 if (GV) {
7200 GV->replaceAllUsesWith(
7201 llvm::ConstantExpr::getBitCast(NewGV, GV->getType()));
7202 GV->eraseFromParent();
7203 }
7204 GV = NewGV;
7205 CGM.getModule().getGlobalList().push_back(GV);
7206 }
7207
7208 assert(GV->getLinkage() == L);
7209 return GV;
7210 }
7211
7212 llvm::Value *
7213 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
7214 IdentifierInfo *II,
7215 const ObjCInterfaceDecl *ID) {
7216 CharUnits Align = CGF.getPointerAlign();
7217 llvm::GlobalVariable *&Entry = ClassReferences[II];
7218
7219 if (!Entry) {
7220 llvm::Constant *ClassGV;
7221 if (ID) {
7222 ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7223 } else {
7224 ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
7225 NotForDefinition);
7226 }
7227
7228 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7229 false, llvm::GlobalValue::PrivateLinkage,
7230 ClassGV, "OBJC_CLASSLIST_REFERENCES_$_");
7231 Entry->setAlignment(Align.getQuantity());
7232 Entry->setSection(GetSectionName("__objc_classrefs",
7233 "regular,no_dead_strip"));
7234 CGM.addCompilerUsedGlobal(Entry);
7235 }
7236 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7237 }
7238
7239 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
7240 const ObjCInterfaceDecl *ID) {
7241 // If the class has the objc_runtime_visible attribute, we need to
7242 // use the Objective-C runtime to get the class.
7243 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
7244 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
7245
7246 return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7247 }
7248
7249 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
7250 CodeGenFunction &CGF) {
7251 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
7252 return EmitClassRefFromId(CGF, II, nullptr);
7253 }
7254
7255 llvm::Value *
7256 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
7257 const ObjCInterfaceDecl *ID) {
7258 CharUnits Align = CGF.getPointerAlign();
7259 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
7260
7261 if (!Entry) {
7262 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7263 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7264 false, llvm::GlobalValue::PrivateLinkage,
7265 ClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7266 Entry->setAlignment(Align.getQuantity());
7267 Entry->setSection(GetSectionName("__objc_superrefs",
7268 "regular,no_dead_strip"));
7269 CGM.addCompilerUsedGlobal(Entry);
7270 }
7271 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7272 }
7273
7274 /// EmitMetaClassRef - Return a Value * of the address of _class_t
7275 /// meta-data
7276 ///
7277 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
7278 const ObjCInterfaceDecl *ID,
7279 bool Weak) {
7280 CharUnits Align = CGF.getPointerAlign();
7281 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
7282 if (!Entry) {
7283 auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
7284
7285 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7286 false, llvm::GlobalValue::PrivateLinkage,
7287 MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7288 Entry->setAlignment(Align.getQuantity());
7289
7290 Entry->setSection(GetSectionName("__objc_superrefs",
7291 "regular,no_dead_strip"));
7292 CGM.addCompilerUsedGlobal(Entry);
7293 }
7294
7295 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7296 }
7297
7298 /// GetClass - Return a reference to the class for the given interface
7299 /// decl.
7300 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
7301 const ObjCInterfaceDecl *ID) {
7302 if (ID->isWeakImported()) {
7303 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7304 (void)ClassGV;
7305 assert(!isa<llvm::GlobalVariable>(ClassGV) ||
7306 cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage());
7307 }
7308
7309 return EmitClassRef(CGF, ID);
7310 }
7311
7312 /// Generates a message send where the super is the receiver. This is
7313 /// a message send to self with special delivery semantics indicating
7314 /// which class's method should be called.
7315 CodeGen::RValue
7316 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
7317 ReturnValueSlot Return,
7318 QualType ResultType,
7319 Selector Sel,
7320 const ObjCInterfaceDecl *Class,
7321 bool isCategoryImpl,
7322 llvm::Value *Receiver,
7323 bool IsClassMessage,
7324 const CodeGen::CallArgList &CallArgs,
7325 const ObjCMethodDecl *Method) {
7326 // ...
7327 // Create and init a super structure; this is a (receiver, class)
7328 // pair we will pass to objc_msgSendSuper.
7329 Address ObjCSuper =
7330 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
7331 "objc_super");
7332
7333 llvm::Value *ReceiverAsObject =
7334 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7335 CGF.Builder.CreateStore(
7336 ReceiverAsObject,
7337 CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
7338
7339 // If this is a class message the metaclass is passed as the target.
7340 llvm::Value *Target;
7341 if (IsClassMessage)
7342 Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
7343 else
7344 Target = EmitSuperClassRef(CGF, Class);
7345
7346 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
7347 // ObjCTypes types.
7348 llvm::Type *ClassTy =
7349 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
7350 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
7351 CGF.Builder.CreateStore(
7352 Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
7353
7354 return (isVTableDispatchedSelector(Sel))
7355 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7356 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7357 true, CallArgs, Method)
7358 : EmitMessageSend(CGF, Return, ResultType,
7359 EmitSelector(CGF, Sel),
7360 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7361 true, CallArgs, Method, Class, ObjCTypes);
7362 }
7363
7364 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
7365 Selector Sel) {
7366 Address Addr = EmitSelectorAddr(CGF, Sel);
7367
7368 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7369 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7370 llvm::MDNode::get(VMContext, None));
7371 return LI;
7372 }
7373
7374 Address CGObjCNonFragileABIMac::EmitSelectorAddr(CodeGenFunction &CGF,
7375 Selector Sel) {
7376 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
7377
7378 CharUnits Align = CGF.getPointerAlign();
7379 if (!Entry) {
7380 llvm::Constant *Casted =
7381 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
7382 ObjCTypes.SelectorPtrTy);
7383 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.SelectorPtrTy,
7384 false, llvm::GlobalValue::PrivateLinkage,
7385 Casted, "OBJC_SELECTOR_REFERENCES_");
7386 Entry->setExternallyInitialized(true);
7387 Entry->setSection(GetSectionName("__objc_selrefs",
7388 "literal_pointers,no_dead_strip"));
7389 Entry->setAlignment(Align.getQuantity());
7390 CGM.addCompilerUsedGlobal(Entry);
7391 }
7392
7393 return Address(Entry, Align);
7394 }
7395
7396 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7397 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7398 ///
7399 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
7400 llvm::Value *src,
7401 Address dst,
7402 llvm::Value *ivarOffset) {
7403 llvm::Type * SrcTy = src->getType();
7404 if (!isa<llvm::PointerType>(SrcTy)) {
7405 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7406 assert(Size <= 8 && "does not support size > 8");
7407 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7408 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7409 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7410 }
7411 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7412 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7413 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
7414 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7415 }
7416
7417 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7418 /// objc_assign_strongCast (id src, id *dst)
7419 ///
7420 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
7421 CodeGen::CodeGenFunction &CGF,
7422 llvm::Value *src, Address dst) {
7423 llvm::Type * SrcTy = src->getType();
7424 if (!isa<llvm::PointerType>(SrcTy)) {
7425 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7426 assert(Size <= 8 && "does not support size > 8");
7427 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7428 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7429 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7430 }
7431 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7432 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7433 llvm::Value *args[] = { src, dst.getPointer() };
7434 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
7435 args, "weakassign");
7436 }
7437
7438 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
7439 CodeGen::CodeGenFunction &CGF,
7440 Address DestPtr,
7441 Address SrcPtr,
7442 llvm::Value *Size) {
7443 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7444 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7445 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
7446 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7447 }
7448
7449 /// EmitObjCWeakRead - Code gen for loading value of a __weak
7450 /// object: objc_read_weak (id *src)
7451 ///
7452 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
7453 CodeGen::CodeGenFunction &CGF,
7454 Address AddrWeakObj) {
7455 llvm::Type *DestTy = AddrWeakObj.getElementType();
7456 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7457 llvm::Value *read_weak =
7458 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
7459 AddrWeakObj.getPointer(), "weakread");
7460 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7461 return read_weak;
7462 }
7463
7464 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7465 /// objc_assign_weak (id src, id *dst)
7466 ///
7467 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
7468 llvm::Value *src, Address dst) {
7469 llvm::Type * SrcTy = src->getType();
7470 if (!isa<llvm::PointerType>(SrcTy)) {
7471 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7472 assert(Size <= 8 && "does not support size > 8");
7473 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7474 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7475 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7476 }
7477 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7478 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7479 llvm::Value *args[] = { src, dst.getPointer() };
7480 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
7481 args, "weakassign");
7482 }
7483
7484 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7485 /// objc_assign_global (id src, id *dst)
7486 ///
7487 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
7488 llvm::Value *src, Address dst,
7489 bool threadlocal) {
7490 llvm::Type * SrcTy = src->getType();
7491 if (!isa<llvm::PointerType>(SrcTy)) {
7492 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7493 assert(Size <= 8 && "does not support size > 8");
7494 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7495 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7496 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7497 }
7498 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7499 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7500 llvm::Value *args[] = { src, dst.getPointer() };
7501 if (!threadlocal)
7502 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
7503 args, "globalassign");
7504 else
7505 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
7506 args, "threadlocalassign");
7507 }
7508
7509 void
7510 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
7511 const ObjCAtSynchronizedStmt &S) {
7512 EmitAtSynchronizedStmt(CGF, S,
7513 cast<llvm::Function>(ObjCTypes.getSyncEnterFn()),
7514 cast<llvm::Function>(ObjCTypes.getSyncExitFn()));
7515 }
7516
7517 llvm::Constant *
7518 CGObjCNonFragileABIMac::GetEHType(QualType T) {
7519 // There's a particular fixed type info for 'id'.
7520 if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
7521 auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
7522 if (!IDEHType) {
7523 IDEHType =
7524 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7525 llvm::GlobalValue::ExternalLinkage, nullptr,
7526 "OBJC_EHTYPE_id");
7527 if (CGM.getTriple().isOSBinFormatCOFF())
7528 IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
7529 }
7530 return IDEHType;
7531 }
7532
7533 // All other types should be Objective-C interface pointer types.
7534 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
7535 assert(PT && "Invalid @catch type.");
7536
7537 const ObjCInterfaceType *IT = PT->getInterfaceType();
7538 assert(IT && "Invalid @catch type.");
7539
7540 return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7541 }
7542
7543 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
7544 const ObjCAtTryStmt &S) {
7545 EmitTryCatchStmt(CGF, S,
7546 cast<llvm::Function>(ObjCTypes.getObjCBeginCatchFn()),
7547 cast<llvm::Function>(ObjCTypes.getObjCEndCatchFn()),
7548 cast<llvm::Function>(ObjCTypes.getExceptionRethrowFn()));
7549 }
7550
7551 /// EmitThrowStmt - Generate code for a throw statement.
7552 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7553 const ObjCAtThrowStmt &S,
7554 bool ClearInsertionPoint) {
7555 if (const Expr *ThrowExpr = S.getThrowExpr()) {
7556 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7557 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7558 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception)
7559 .setDoesNotReturn();
7560 } else {
7561 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn())
7562 .setDoesNotReturn();
7563 }
7564
7565 CGF.Builder.CreateUnreachable();
7566 if (ClearInsertionPoint)
7567 CGF.Builder.ClearInsertionPoint();
7568 }
7569
7570 llvm::Constant *
7571 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7572 ForDefinition_t IsForDefinition) {
7573 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7574 StringRef ClassName = ID->getObjCRuntimeNameAsString();
7575
7576 // If we don't need a definition, return the entry if found or check
7577 // if we use an external reference.
7578 if (!IsForDefinition) {
7579 if (Entry)
7580 return Entry;
7581
7582 // If this type (or a super class) has the __objc_exception__
7583 // attribute, emit an external reference.
7584 if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
7585 std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
7586 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
7587 false, llvm::GlobalValue::ExternalLinkage,
7588 nullptr, EHTypeName);
7589 CGM.setGVProperties(Entry, ID);
7590 return Entry;
7591 }
7592 }
7593
7594 // Otherwise we need to either make a new entry or fill in the initializer.
7595 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7596
7597 std::string VTableName = "objc_ehtype_vtable";
7598 auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
7599 if (!VTableGV) {
7600 VTableGV =
7601 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
7602 llvm::GlobalValue::ExternalLinkage, nullptr,
7603 VTableName);
7604 if (CGM.getTriple().isOSBinFormatCOFF())
7605 VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
7606 }
7607
7608 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7609 ConstantInitBuilder builder(CGM);
7610 auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
7611 values.add(
7612 llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(),
7613 VTableGV, VTableIdx));
7614 values.add(GetClassName(ClassName));
7615 values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
7616
7617 llvm::GlobalValue::LinkageTypes L = IsForDefinition
7618 ? llvm::GlobalValue::ExternalLinkage
7619 : llvm::GlobalValue::WeakAnyLinkage;
7620 if (Entry) {
7621 values.finishAndSetAsInitializer(Entry);
7622 Entry->setAlignment(CGM.getPointerAlign().getQuantity());
7623 } else {
7624 Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
7625 CGM.getPointerAlign(),
7626 /*constant*/ false,
7627 L);
7628 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7629 CGM.setGVProperties(Entry, ID);
7630 }
7631 assert(Entry->getLinkage() == L);
7632
7633 if (!CGM.getTriple().isOSBinFormatCOFF())
7634 if (ID->getVisibility() == HiddenVisibility)
7635 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7636
7637 if (IsForDefinition)
7638 if (CGM.getTriple().isOSBinFormatMachO())
7639 Entry->setSection("__DATA,__objc_const");
7640
7641 return Entry;
7642 }
7643
7644 /* *** */
7645
7646 CodeGen::CGObjCRuntime *
7647 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7648 switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7649 case ObjCRuntime::FragileMacOSX:
7650 return new CGObjCMac(CGM);
7651
7652 case ObjCRuntime::MacOSX:
7653 case ObjCRuntime::iOS:
7654 case ObjCRuntime::WatchOS:
7655 return new CGObjCNonFragileABIMac(CGM);
7656
7657 case ObjCRuntime::GNUstep:
7658 case ObjCRuntime::GCC:
7659 case ObjCRuntime::ObjFW:
7660 llvm_unreachable("these runtimes are not Mac runtimes");
7661 }
7662 llvm_unreachable("bad runtime");
7663 }
clang::CodeGen::CodeGenTypes::arrangeBuiltinFunctionDeclaration
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
Definition: CGCall.cpp:659
clang::CodeGen::RValue::isAggregate
bool isAggregate() const
Definition: CGValue.h:54
clang::CodeGen::CodeGenModule::getDataLayout
const llvm::DataLayout & getDataLayout() const
Definition: CodeGenModule.h:661
clang::CodeGen::ReturnValueSlot
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:361
clang::Builtin::ID
ID
Definition: Builtins.h:49
clang::ast_matchers::type
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchersInternal.cpp:592
ASTContext.h
Defines the clang::ASTContext interface.
clang::CanQual::withConst
QualType withConst() const
Retrieves a version of this type with const applied.
Definition: CanonicalType.h:162
clang::ObjCMethodDecl::isClassMethod
bool isClassMethod() const
Definition: DeclObjC.h:430
clang::CodeGen::CGBlockInfo::getCapture
const Capture & getCapture(const VarDecl *var) const
Definition: CGBlocks.h:271
clang::CodeGen::CodeGenTypeCache::IntTy
llvm::IntegerType * IntTy
int
Definition: CodeGenTypeCache.h:43
clang::Qualifiers::GCNone
Definition: Type.h:151
clang::ExternalLinkage
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:60
clang::CodeGen::CGBlockInfo::BlockHeaderForcedGapOffset
CharUnits BlockHeaderForcedGapOffset
Definition: CGBlocks.h:256
clang::ObjCObjectPointerType::isObjCQualifiedIdType
bool isObjCQualifiedIdType() const
True if this is equivalent to &#39;id.
Definition: Type.h:5873
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:673
clang::ASTContext::getObjCIdType
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1849
NonFragileABI_Class_CompiledByARC
Class implementation was compiled under ARC.
Definition: CGObjCMac.cpp:3396
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2537
clang::ASTContext::VoidPtrTy
CanQualType VoidPtrTy
Definition: ASTContext.h:1044
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:638
clang::Type::isBlockPointerType
bool isBlockPointerType() const
Definition: Type.h:6304
clang::CodeGen::CodeGenModule::ReturnTypeUsesSRet
bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)
Return true iff the given type uses &#39;sret&#39; when used as a return type.
Definition: CGCall.cpp:1506
clang::CodeGen::CodeGenModule::getTypes
CodeGenTypes & getTypes()
Definition: CodeGenModule.h:676
clang::Type::isArrayType
bool isArrayType() const
Definition: Type.h:6345
clang::ObjCMethodDecl::getClassInterface
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1144
size_t
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:68
clang::CodeGen::CodeGenFunction::HaveInsertPoint
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
Definition: CodeGenFunction.h:2078
clang::CodeGen::CodeGenModule::getLLVMContext
llvm::LLVMContext & getLLVMContext()
Definition: CodeGenModule.h:670
clang::ASTContext::getPointerDiffType
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
Definition: ASTContext.cpp:5002
clang::CodeGen::ConstantInitBuilder
The standard implementation of ConstantInitBuilder used in Clang.
Definition: ConstantInitBuilder.h:517
clang::ASTContext::getASTRecordLayout
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
Definition: RecordLayoutBuilder.cpp:2966
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:66
clang::ObjCAtTryStmt::getFinallyStmt
const ObjCAtFinallyStmt * getFinallyStmt() const
Retrieve the @finally statement, if any.
Definition: StmtObjC.h:224
clang::CodeGen::ReturnValueSlot::isUnused
bool isUnused() const
Definition: CGCall.h:382
clang::TargetInfo::getTriple
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:953
clang::CodeGen::CGObjCRuntime
Implements runtime-specific code generation functions.
Definition: CGObjCRuntime.h:64
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6369
clang::ASTContext::getASTObjCImplementationLayout
const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const
Get or compute information about the layout of the specified Objective-C implementation.
Definition: ASTContext.cpp:2613
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
clang::CodeGen::CodeGenTypeCache::getPointerSize
CharUnits getPointerSize() const
Definition: CodeGenTypeCache.h:106
clang::CodeGen::CodeGenFunction::CurCodeDecl
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
Definition: CodeGenFunction.h:298
clang::Decl::add
static void add(Kind k)
Definition: DeclBase.cpp:193
FragileABI_Class_Meta
Is a meta-class.
Definition: CGObjCMac.cpp:3360
llvm::DenseSet
Definition: Sema.h:66
P
StringRef P
Definition: ASTMatchersInternal.cpp:439
clang::ObjCInterfaceDecl::all_referenced_protocol_begin
all_protocol_iterator all_referenced_protocol_begin() const
Definition: DeclObjC.h:1429
clang::CodeGen::CodeGenFunction::EmitAutoVarDecl
void EmitAutoVarDecl(const VarDecl &D)
EmitAutoVarDecl - Emit an auto variable declaration.
Definition: CGDecl.cpp:1200
FragileABI_Class_HasCXXStructors
Has a non-trivial constructor or destructor.
Definition: CGObjCMac.cpp:3363
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1407
clang::ObjCAtThrowStmt
Represents Objective-C&#39;s @throw statement.
Definition: StmtObjC.h:313
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2812
clang::ObjCImplementationDecl::hasDestructors
bool hasDestructors() const
Do any of the ivars of this class (not counting its base classes) require non-trivial destruction...
Definition: DeclObjC.h:2659
hasObjCExceptionAttribute
static bool hasObjCExceptionAttribute(ASTContext &Context, const ObjCInterfaceDecl *OID)
hasObjCExceptionAttribute - Return true if this class or any super class has the objc_exception attri...
Definition: CGObjCMac.cpp:1799
DeclObjC.h
GetGCAttrTypeForType
static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT, bool pointee=false)
Definition: CGObjCMac.cpp:2188
clang::TargetInfo::getCharWidth
unsigned getCharWidth() const
Definition: TargetInfo.h:371
clang::ObjCMethodDecl::param_end
param_const_iterator param_end() const
Definition: DeclObjC.h:352
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:2847
Value
Value
Definition: UninitializedValues.cpp:102
NonFragileABI_Class_Root
Is a root class.
Definition: CGObjCMac.cpp:3381
clang::CodeGen::CodeGenFunction::GetAddrOfLocalVar
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
Definition: CodeGenFunction.h:2344
clang::CodeGen::CodeGenFunction::EmitCall
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::Instruction **callOrInvoke, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
Definition: CGCall.cpp:3807
clang::ASTContext::getCanonicalParamType
CanQualType getCanonicalParamType(QualType T) const
Return the canonical parameter type corresponding to the specific potentially non-canonical one...
Definition: ASTContext.cpp:5023
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:813
clang::HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition: Visibility.h:37
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6748
clang::CodeGen::ConstantAggregateBuilderTemplateBase::finishAndCreateGlobal
llvm::GlobalVariable * finishAndCreateGlobal(As &&...args)
Given that this builder was created by beginning an array or struct directly on a ConstantInitBuilder...
Definition: ConstantInitBuilder.h:370
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
clang::ASTContext::getObjCClassType
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:1871
clang::CodeGen::Address::getPointer
llvm::Value * getPointer() const
Definition: Address.h:38
StmtObjC.h
Defines the Objective-C statement AST node classes.
clang::CodeGen::CodeGenTypes::ConvertTypeForMem
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
Definition: CodeGenTypes.cpp:87
clang::ObjCProtocolDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:2129
clang::MultiVersionKind::Target
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1550
clang::Linkage
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:24
clang::CodeGen::CallArgList::add
void add(RValue rvalue, QualType type)
Definition: CGCall.h:285
clang::CodeGen::CodeGenFunction::JumpDest
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
Definition: CodeGenFunction.h:235
clang::CodeGen::CodeGenFunction::EmitObjCThrowOperand
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
Definition: CGObjC.cpp:3208
FragileABI_Class_CompiledByARC
Class implementation was compiled under ARC.
Definition: CGObjCMac.cpp:3369
clang::NamedDecl::getIdentifier
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3593
clang::TargetInfo::getPointerWidth
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:349
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:58
CGRecordLayout.h
clang::ObjCObjectType
Represents a class type in Objective C.
Definition: Type.h:5538
clang::CodeGen::CodeGenFunction
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Definition: CodeGenFunction.h:227
clang::CodeGen::CodeGenTypes::ConvertType
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Definition: CodeGenTypes.cpp:383
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
clang::ObjCMethodDecl::param_const_iterator
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:343
clang::RecordDecl::fields
field_range fields() const
Definition: Decl.h:3784
NonFragileABI_Class_HasCXXDestructorOnly
Class has non-trivial destructors, but zero-initialization is okay.
Definition: CGObjCMac.cpp:3399
clang::Type::isObjCIdType
bool isObjCIdType() const
Definition: Type.h:6422
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2579
clang::ObjCProtocolDecl::protocol_begin
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:2133
MethodListType
MethodListType
Definition: CGObjCMac.cpp:1101
clang::CodeGen::ARCImpreciseLifetime
Definition: CGValue.h:121
clang::CodeGen::CodeGenTypeCache::getSizeAlign
CharUnits getSizeAlign() const
Definition: CodeGenTypeCache.h:103
clang::CodeGen::CodeGenFunction::EmitRuntimeCall
llvm::CallInst * EmitRuntimeCall(llvm::Value *callee, const Twine &name="")
clang::Qualifiers::ObjCLifetime
ObjCLifetime
Definition: Type.h:156
clang::ObjCContainerDecl::methods
method_range methods() const
Definition: DeclObjC.h:1037
clang::ObjCProtocolDecl::getObjCRuntimeNameAsString
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for protocol&#39;s metadata.
Definition: DeclObjC.cpp:1961
clang::ObjCPropertyDecl::getSetterMethodDecl
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:925
clang::ObjCImplementationDecl::getNameAsString
std::string getNameAsString() const
Get the name of the class associated with this interface.
Definition: DeclObjC.h:2681
NonFragileABI_Class_HasMRCWeakIvars
Class implementation was compiled under MRC and has MRC weak ivars.
Definition: CGObjCMac.cpp:3403
clang::ObjCContainerDecl::properties
prop_range properties() const
Definition: DeclObjC.h:988
Category
int Category
Definition: Format.cpp:1632
clang::CodeGen::CodeGenFunction::Builder
CGBuilderTy Builder
Definition: CodeGenFunction.h:263
clang::CharUnits::Zero
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
clang::Type::isObjCQualifiedClassType
bool isObjCQualifiedClassType() const
Definition: Type.h:6416
llvm::SmallVectorImpl
Definition: LLVM.h:37
clang::ASTContext::Idents
IdentifierTable & Idents
Definition: ASTContext.h:566
NonFragileABI_Class_Exception
Has the exception attribute.
Definition: CGObjCMac.cpp:3390
getBlockLayoutInfoString
static std::string getBlockLayoutInfoString(const SmallVectorImpl< CGObjCCommonMac::RUN_SKIP > &RunSkipBlockVars, bool HasCopyDisposeHelpers)
Definition: CGObjCMac.cpp:2804
clang::Selector::isUnarySelector
bool isUnarySelector() const
Definition: IdentifierTable.h:750
clang::DefaultVisibility
Objects with "default" visibility are seen by the dynamic linker and act like normal objects...
Definition: Visibility.h:46
clang::ObjCAtCatchStmt
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:74
isWeakLinkedClass
static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID)
Definition: CGObjCMac.cpp:2067
clang::ObjCImplementationDecl::hasNonZeroConstructors
bool hasNonZeroConstructors() const
Do any of the ivars of this class (not counting its base classes) require construction other than zer...
Definition: DeclObjC.h:2654
clang::FieldDecl::isBitField
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2657
clang::CodeGen::CGBlockInfo::Capture::isConstant
bool isConstant() const
Definition: CGBlocks.h:173
clang::Qualifiers::GC
GC
Definition: Type.h:150
clang::ObjCRuntime::isNonFragile
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:82
clang::ObjCContainerDecl
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:969
clang::ObjCAtThrowStmt::getThrowExpr
const Expr * getThrowExpr() const
Definition: StmtObjC.h:325
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
clang::CodeGen::CGBlockInfo::getBlockDecl
const BlockDecl * getBlockDecl() const
Definition: CGBlocks.h:281
dump
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Definition: CoverageMappingGen.cpp:1291
GCCTypeClass::None
clang::GetNullarySelector
Selector GetNullarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing a nullary selector.
Definition: ASTContext.h:2953
clang::ASTContext::getObjCClassRedefinitionType
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
Definition: ASTContext.h:1649
clang::ObjCProtocolDecl::getDefinition
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
Definition: DeclObjC.h:2210
clang::FieldDecl::getBitWidthValue
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3787
NULL
#define NULL
Definition: opencl-c.h:158
clang::CodeGen::CodeGenFunction::createBasicBlock
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
Definition: CodeGenFunction.h:2037
clang::CodeGen::CodeGenModule::addCompilerUsedGlobal
void addCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
Definition: CodeGenModule.cpp:1614
clang::CodeGen::CodeGenFunction::RunCleanupsScope::ForceCleanup
void ForceCleanup(std::initializer_list< llvm::Value **> ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
Definition: CodeGenFunction.h:745
clang::ObjCProtocolDecl
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2064
clang::CodeGen::CodeGenModule::CreateRuntimeVariable
llvm::Constant * CreateRuntimeVariable(llvm::Type *Ty, StringRef Name)
Create a new runtime global variable with the specified type and name.
Definition: CodeGenModule.cpp:3302
clang::CodeGen::CodeGenTypeCache::getPointerAlign
CharUnits getPointerAlign() const
Definition: CodeGenTypeCache.h:109
clang::CodeGen::ForDefinition_t
ForDefinition_t
Definition: CodeGenModule.h:98
clang::CodeGen::CodeGenFunction::CreateTempAlloca
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:106
CGFunctionInfo.h
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1172
clang::CodeGen::CodeGenTypeCache::VoidTy
llvm::Type * VoidTy
void
Definition: CodeGenTypeCache.h:35
clang::ObjCMethodDecl::getReturnType
QualType getReturnType() const
Definition: DeclObjC.h:323
llvm::ArrayRef
Definition: LLVM.h:32
clang::ObjCObjectType::getInterface
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5773
clang::CodeGen::CodeGenFunction::NormalCleanupDest
Address NormalCleanupDest
i32s containing the indexes of the cleanup destinations.
Definition: CodeGenFunction.h:524
clang::ObjCInterfaceDecl::all_referenced_protocol_end
all_protocol_iterator all_referenced_protocol_end() const
Definition: DeclObjC.h:1442
llvm::SmallString
Definition: LLVM.h:35
clang::CodeGen::RValue::getAggregateAddress
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:71
clang::ASTContext::getObjCProtoType
QualType getObjCProtoType() const
Retrieve the type of the Objective-C Protocol class.
Definition: ASTContext.h:1895
clang::Qualifiers::OCL_ExplicitNone
This object can be modified without requiring retains or releases.
Definition: Type.h:162
clang::CodeGen::CodeGenModule::CreateRuntimeFunction
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false)
Create a new runtime function with the specified type and name.
Definition: CodeGenModule.cpp:2957
clang::ObjCAtTryStmt::getCatchStmt
const ObjCAtCatchStmt * getCatchStmt(unsigned I) const
Retrieve a @catch statement.
Definition: StmtObjC.h:206
clang::CodeGen::CGBlockInfo::Capture::getIndex
unsigned getIndex() const
Definition: CGBlocks.h:175
clang::Decl::hasAttr
bool hasAttr() const
Definition: DeclBase.h:531
llvm::str
return Out str()
clang::CodeGen::Address::isValid
bool isValid() const
Definition: Address.h:36
clang::StringLiteral::getString
StringRef getString() const
Definition: Expr.h:1649
clang::CharUnits::One
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
clang::CodeGen::CallArgList::addFrom
void addFrom(const CallArgList &other)
Add all the arguments from another CallArgList to this one.
Definition: CGCall.h:294
clang::CodeGen::CodeGenFunction::ComplexPairTy
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
Definition: CodeGenFunction.h:261
clang::CodeGen::CodeGenFunction::getContext
ASTContext & getContext() const
Definition: CodeGenFunction.h:1596
clang::CodeGen::CodeGenFunction::EmitNounwindRuntimeCall
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
clang::CodeGen::CGBlockInfo
CGBlockInfo - Information to generate a block literal.
Definition: CGBlocks.h:153
clang::CodeGen::RValue
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:39
clang::CharUnits::getQuantity
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
GetConstantStringEntry
static llvm::StringMapEntry< llvm::GlobalVariable * > & GetConstantStringEntry(llvm::StringMap< llvm::GlobalVariable *> &Map, const StringLiteral *Literal, unsigned &StringLength)
Definition: CGObjCMac.cpp:1879
clang::ObjCProtocolDecl::hasDefinition
bool hasDefinition() const
Determine whether this protocol has a definition.
Definition: DeclObjC.h:2198
Offset
unsigned Offset
Definition: Format.cpp:1631
clang::ASTRecordLayout
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
clang::CodeGen::CodeGenTypeCache::getRuntimeCC
llvm::CallingConv::ID getRuntimeCC() const
Definition: CodeGenTypeCache.h:114
clang::QualType::isObjCGCStrong
bool isObjCGCStrong() const
true when Type is objc&#39;s strong.
Definition: Type.h:1053
clang::BlockDecl
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3858
clang::Expr
This represents one expression.
Definition: Expr.h:106
LangOptions.h
Defines the clang::LangOptions interface.
clang::CodeGen::Address::invalid
static Address invalid()
Definition: Address.h:35
CodeGenModule.h
Label
std::string Label
Definition: UsingDeclarationsSorter.cpp:70
clang::CodeGen::CodeGenFunction::RunCleanupsScope
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
Definition: CodeGenFunction.h:700
clang::CodeGen::CGBlockInfo::Capture::getOffset
CharUnits getOffset() const
Definition: CGBlocks.h:179
clang::CodeGen::RValue::getComplexVal
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
Definition: CGValue.h:66
clang::CodeGen::CodeGenFunction::JumpDest::getBlock
llvm::BasicBlock * getBlock() const
Definition: CodeGenFunction.h:243
clang::CodeGen::CGCallee::forDirect
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:134
clang::ast_matchers::decl
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchersInternal.cpp:561
FragileABI_Class_Hidden
Has hidden visibility.
Definition: CGObjCMac.cpp:3366
CGObjCRuntime.h
clang::Selector::getNameForSlot
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
Definition: IdentifierTable.cpp:436
clang::Type::isObjCClassType
bool isObjCClassType() const
Definition: Type.h:6428
clang::ObjCObjectPointerType::isObjCIdType
bool isObjCIdType() const
True if this is equivalent to the &#39;id&#39; type, i.e.
Definition: Type.h:5856
clang::ObjCAtSynchronizedStmt
Represents Objective-C&#39;s @synchronized statement.
Definition: StmtObjC.h:262
clang::ObjCInterfaceDecl::getSuperClass
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:338
clang::CharUnits::fromQuantity
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
clang::CodeGen::CodeGenFunction::getLLVMContext
llvm::LLVMContext & getLLVMContext()
Definition: CodeGenFunction.h:1639
clang::CodeGen::CGBlockInfo::needsCopyDisposeHelpers
bool needsCopyDisposeHelpers() const
Definition: CGBlocks.h:291
clang::CodeGen::CodeGenModule::ReturnSlotInterferesWithArgs
bool ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI)
Return true iff the given type uses an argument slot when &#39;sret&#39; is used as a return type...
Definition: CGCall.cpp:1511
clang::CodeGen::CodeGenTypeCache::Int32Ty
llvm::IntegerType * Int32Ty
Definition: CodeGenTypeCache.h:38
clang::LangOptions::ObjCRuntime
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:207
clang::ObjCImplDecl::property_impls
propimpl_range property_impls() const
Definition: DeclObjC.h:2467
clang::ObjCMethodDecl::isInstanceMethod
bool isInstanceMethod() const
Definition: DeclObjC.h:422
getConstantGEP
static llvm::Constant * getConstantGEP(llvm::LLVMContext &VMContext, llvm::GlobalVariable *C, unsigned idx0, unsigned idx1)
getConstantGEP() - Help routine to construct simple GEPs.
Definition: CGObjCMac.cpp:1787
clang::Selector::getNumArgs
unsigned getNumArgs() const
Definition: IdentifierTable.cpp:414
clang::CodeGen::CodeGenModule::getTarget
const TargetInfo & getTarget() const
Definition: CodeGenModule.h:664
clang::ObjCMethodDecl::getSelector
Selector getSelector() const
Definition: DeclObjC.h:321
length
float __ovld __cnfn length(float p)
Return the length of vector p, i.e., sqrt(p.x2 + p.y 2 + ...)
clang::Type::isUnionType
bool isUnionType() const
Definition: Type.cpp:475
clang::CodeGen::CodeGenModule::getLangOpts
const LangOptions & getLangOpts() const
Definition: CodeGenModule.h:653
clang::CodeGen::CodeGenModule::getContext
ASTContext & getContext() const
Definition: CodeGenModule.h:652
CodeGenFunction.h
NonFragileABI_Class_HasIvarReleaser
(Obsolete) ARC-specific: this class has a .release_ivars method
Definition: CGObjCMac.cpp:3393
clang::Type::getCanonicalTypeUnqualified
CanQualType getCanonicalTypeUnqualified() const
Definition: CanonicalType.h:215
clang::CodeGen::AlignmentSource::Type
The l-value was considered opaque, so the alignment was determined from a type.
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4380
clang::ASTRecordLayout::getFieldOffset
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:191
clang::ObjCIvarDecl::Private
Definition: DeclObjC.h:1950
CGCleanup.h
clang::Qualifiers::OCL_None
There is no lifetime qualification on this type.
Definition: Type.h:158
clang::CodeGen::CGBuilderTy::CreateBitCast
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:142
clang::ASTContext::getObjCIdRedefinitionType
QualType getObjCIdRedefinitionType() const
Retrieve the type that id has been defined to, which may be different from the built-in id if id has ...
Definition: ASTContext.h:1636
clang::ASTContext::Selectors
SelectorTable & Selectors
Definition: ASTContext.h:567
clang::Qualifiers::OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:169
Kind
Kind
Definition: ChrootChecker.cpp:29
clang::CodeGen::CodeGenFunction::CurFn
llvm::Function * CurFn
Definition: CodeGenFunction.h:301
clang::CodeGen::CodeGenModule::ReturnTypeUsesFPRet
bool ReturnTypeUsesFPRet(QualType ResultType)
Return true iff the given type uses &#39;fpret&#39; when used as a return type.
Definition: CGCall.cpp:1516
clang::CodeGen::CodeGenFunction::EnsureInsertPoint
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
Definition: CodeGenFunction.h:2086
clang::IdentifierTable::get
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Definition: IdentifierTable.h:519
clang::CodeGen::CodeGenFunction::EmitARCRelease
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition: CGObjC.cpp:2172
clang::ObjCAtCatchStmt::getCatchBody
const Stmt * getCatchBody() const
Definition: StmtObjC.h:90
clang::CodeGen::CodeGenModule::GetAddrOfConstantCFString
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
Definition: CodeGenModule.cpp:4208
clang::CodeGen::CGBlockInfo::StructureType
llvm::StructType * StructureType
Definition: CGBlocks.h:246
clang::CodeGen::CodeGenFunction::ObjCEHValueStack
SmallVector< llvm::Value *, 8 > ObjCEHValueStack
ObjCEHValueStack - Stack of Objective-C exception values, used for rethrows.
Definition: CodeGenFunction.h:563
clang::NamedDecl::getNameAsString
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Definition: Decl.h:292
clang::CodeGen::CodeGenModule::setGVProperties
void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const
Set visibility, dllimport/dllexport and dso_local.
Definition: CodeGenModule.cpp:837
clang::ASTContext::getObjCSelType
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C &#39;SEL&#39; type.
Definition: ASTContext.h:1859
llvm::SmallSetVector< llvm::CachedHashString, 16 >
clang::CodeGen::CodeGenTypes::arrangeObjCMethodDeclaration
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Objective-C methods are C functions with some implicit parameters.
Definition: CGCall.cpp:461
clang::CodeGen::CodeGenFunction::EmitStmt
void EmitStmt(const Stmt *S, ArrayRef< const Attr *> Attrs=None)
EmitStmt - Emit the code for the statement.
Definition: CGStmt.cpp:46
PushProtocolProperties
static void PushProtocolProperties(llvm::SmallPtrSet< const IdentifierInfo *, 16 > &PropertySet, SmallVectorImpl< const ObjCPropertyDecl *> &Properties, const ObjCProtocolDecl *Proto, bool IsClassProperty)
Definition: CGObjCMac.cpp:3153
hasMRCWeakIvars
static bool hasMRCWeakIvars(CodeGenModule &CGM, const ObjCImplementationDecl *ID)
For compatibility, we only want to set the "HasMRCWeakIvars" flag (and actually fill in a layout stri...
Definition: CGObjCMac.cpp:3424
clang::CodeGen::CodeGenModule::GetAddrOfRTTIDescriptor
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
Definition: CodeGenModule.cpp:5309
clang::ASTContext::getAsArrayType
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
Definition: ASTContext.cpp:5409
clang::ObjCCategoryDecl
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2280
clang::CanQual< Type >
clang::ASTContext::VoidTy
CanQualType VoidTy
Definition: ASTContext.h:1016
NonFragileClassFlags
NonFragileClassFlags
Definition: CGObjCMac.cpp:3376
hasWeakMember
static bool hasWeakMember(QualType type)
Definition: CGObjCMac.cpp:3406
llvm::SmallVector
Definition: LLVM.h:36
clang::Type::isObjCObjectPointerType
bool isObjCObjectPointerType() const
Definition: Type.h:6393
clang::CodeGen::Address
An aligned address.
Definition: Address.h:25
clang::ObjCPropertyDecl
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:729
FragileABI_Class_HasMRCWeakIvars
Class implementation was compiled under MRC and has MRC weak ivars.
Definition: CGObjCMac.cpp:3373
clang::ObjCInterfaceDecl::isSuperClassOf
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Definition: DeclObjC.h:1810
clang::CodeGen::CGCallee
All available information about a concrete callee.
Definition: CGCall.h:67
clang::operator<
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
Definition: DeclarationName.h:541
clang::CodeGen::CGBlockInfo::BlockSize
CharUnits BlockSize
Definition: CGBlocks.h:249
clang::CodeGen::CodeGenFunction::getJumpDestInCurrentScope
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
Definition: CodeGenFunction.h:961
clang::Qualifiers::OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
Definition: Type.h:175
clang::ASTContext::getPreferredTypeAlign
unsigned getPreferredTypeAlign(const Type *T) const
Return the "preferred" alignment of the specified type T for the current target, in bits...
Definition: ASTContext.cpp:2197
clang::CodeGen::CodeGenModule::ReturnTypeUsesFP2Ret
bool ReturnTypeUsesFP2Ret(QualType ResultType)
Return true iff the given type uses &#39;fp2ret&#39; when used as a return type.
Definition: CGCall.cpp:1533
FragileClassFlags
FragileClassFlags
Definition: CGObjCMac.cpp:3355
clang::Decl::isWeakImported
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition: DeclBase.cpp:685
clang::CodeGen::CodeGenModule::GetAddrOfConstantCString
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating &#39;\0&#39; character...
Definition: CodeGenModule.cpp:4553
clang::LangOptions::NonGC
Definition: LangOptions.h:54
clang::IdentifierInfo::getName
StringRef getName() const
Return the actual identifier string.
Definition: IdentifierTable.h:156
clang::CodeGen::CodeGenFunction::EmitScalarExpr
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
Definition: CGExprScalar.cpp:4290
clang::CodeGen::CodeGenModule::addUsedGlobal
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
Definition: CodeGenModule.cpp:1608
clang::ObjCIvarDecl::getNextIvar
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1978
clang::QualType::isObjCGCWeak
bool isObjCGCWeak() const
true when Type is objc&#39;s weak.
Definition: Type.h:1048
clang::CodeGen::RValue::getScalarVal
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:59
clang::ASTContext::CharTy
CanQualType CharTy
Definition: ASTContext.h:1018
CGBlocks.h
clang::CodeGen::CodeGenFunction::EHStack
EHScopeStack EHStack
Definition: CodeGenFunction.h:490
clang::CodeGen::CodeGenModule
This class organizes the cross-function state that is used while generating LLVM code.
Definition: CodeGenModule.h:274
clang::ObjCProtocolDecl::protocol_end
protocol_iterator protocol_end() const
Definition: DeclObjC.h:2140
clang::CodeGen::ConstantAggregateBuilderTemplateBase::beginStruct
StructBuilder beginStruct(llvm::StructType *ty=nullptr)
Definition: ConstantInitBuilder.h:348
clang::ObjCImplDecl::getClassInterface
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2440
addIfPresent
static void addIfPresent(llvm::DenseSet< llvm::Value *> &S, Address V)
Definition: CGObjCMac.cpp:4239
clang::Qualifiers::Weak
Definition: Type.h:152
Decl.h
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::ASTRecordLayout::getSize
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:184
clang::CodeGen::RValue::getComplex
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
Definition: CGValue.h:93
clang::BlockDecl::captures
ArrayRef< Capture > captures() const
Definition: Decl.h:3985
clang::ObjCImplDecl
Definition: DeclObjC.h:2425
clang::CodeGen::CGBuilderTy::CreateStructGEP
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:172
CodeGenOptions.h
clang::CodeGen::CGBuilderTy::CreateAlignedLoad
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:91
type
clang::serialized_diags::create
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
Definition: SerializedDiagnosticPrinter.cpp:297
clang::CodeGen::CGBuilderTy::CreateLoad
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:70
clang::CodeGen::CodeGenTypeCache::IntPtrTy
llvm::IntegerType * IntPtrTy
Definition: CodeGenTypeCache.h:47
clang::CodeGen::CodeGenModule::EmitNullConstant
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
Definition: CGExprConstant.cpp:2143
clang::ObjCObjectPointerType::getObjectType
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5835
printf
int printf(__constant const char *st,...)
clang::ObjCIvarDecl::getContainingInterface
const ObjCInterfaceDecl * getContainingInterface() const
Return the class interface that this ivar is logically contained in; this is either the interface whe...
Definition: DeclObjC.cpp:1790
clang::CodeGen::CGBuilderTy::CreateStore
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:108
clang::CodeGen::CodeGenModule::getModule
llvm::Module & getModule() const
Definition: CodeGenModule.h:659
FragileABI_Class_Factory
Apparently: is not a meta-class.
Definition: CGObjCMac.cpp:3357
clang::CodeGen::CodeGenFunction::getNormalCleanupDestSlot
Address getNormalCleanupDestSlot()
Definition: CGCleanup.cpp:1270
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:5794
clang::Qualifiers::Strong
Definition: Type.h:153
clang::ObjCImplementationDecl
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2552
NonFragileABI_Class_Hidden
Has hidden visibility.
Definition: CGObjCMac.cpp:3387
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4370
clang::ObjCInterfaceDecl::getObjCRuntimeNameAsString
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for class&#39;s metadata.
Definition: DeclObjC.cpp:1533
clang::CodeGen::ConstantInitBuilderTemplateBase::beginStruct
StructBuilder beginStruct(llvm::StructType *structTy=nullptr)
Definition: ConstantInitBuilder.h:500
clang::SelectorTable::getSelector
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
Definition: IdentifierTable.cpp:635
clang::CodeGen::Address::getElementType
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
clang::ConstantArrayType::getSize
const llvm::APInt & getSize() const
Definition: Type.h:2890
clang::CodeGen::CodeGenTypes
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:119
clang::ObjCCategoryDecl::protocol_begin
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:2360
clang::CodeGen::CodeGenTypeCache::Int8PtrTy
llvm::PointerType * Int8PtrTy
Definition: CodeGenTypeCache.h:55
clang::Type::isObjCQualifiedIdType
bool isObjCQualifiedIdType() const
Definition: Type.h:6410
clang::CodeGen::CGBlockInfo::Capture
Definition: CGBlocks.h:161
clang::ObjCMethodDecl::param_begin
param_const_iterator param_begin() const
Definition: DeclObjC.h:348
clang::ObjCImplementationDecl::getObjCRuntimeNameAsString
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for class&#39;s metadata.
Definition: DeclObjC.cpp:1541
clang::ObjCAtFinallyStmt
Represents Objective-C&#39;s @finally statement.
Definition: StmtObjC.h:120
clang::InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:32
clang::CodeGen::CodeGenFunction::EmitBlock
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:443
clang::ASTContext::getTypeSize
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2070
clang::CodeGen::CodeGenFunction::CurFuncDecl
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
Definition: CodeGenFunction.h:296
clang::ASTContext::getCanonicalType
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2253
NonFragileABI_Class_Meta
Is a meta-class.
Definition: CGObjCMac.cpp:3378
clang::ObjCPropertyImplDecl::Synthesize
Definition: DeclObjC.h:2762
clang::CodeGen::CodeGenTypeCache::PtrDiffTy
llvm::IntegerType * PtrDiffTy
Definition: CodeGenTypeCache.h:49
clang::ASTContext::toCharUnitsFromBits
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Definition: ASTContext.cpp:2156
clang::Qualifiers::OCL_Weak
Reading or writing from this object requires a barrier call.
Definition: Type.h:172
clang::CodeGen::ForDefinition
Definition: CodeGenModule.h:100
clang::CodeGen::NormalAndEHCleanup
Definition: EHScopeStack.h:87
clang::GetUnarySelector
Selector GetUnarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing an unary selector.
Definition: ASTContext.h:2959
clang::Type::isVoidType
bool isVoidType() const
Definition: Type.h:6544
RecordLayout.h
clang::CodeGen::CodeGenFunction::ConvertType
llvm::Type * ConvertType(QualType T)
Definition: CodeGenFunction.cpp:188
clang::CodeGen::ConstantAddress
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:75
clang::ObjCIvarDecl
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1945
clang::CodeGen::CodeGenFunction::ReturnValue
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
Definition: CodeGenFunction.h:329
clang::CodeGen::ConstantStructBuilder
A helper class of ConstantInitBuilder, used for building constant struct initializers.
Definition: ConstantInitBuilder.h:543
kCFTaggedObjectID_Integer
Definition: CGObjCMac.cpp:1983
clang::ASTContext::getPointerType
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
Definition: ASTContext.cpp:2847
clang::diag::kind
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
clang::CodeGen::CGBlockInfo::BlockHeaderForcedGapSize
CharUnits BlockHeaderForcedGapSize
Definition: CGBlocks.h:259
NonFragileABI_Class_HasCXXStructors
Has a non-trivial constructor or destructor.
Definition: CGObjCMac.cpp:3384
clang::ObjCAtTryStmt
Represents Objective-C&#39;s @try ... @catch ... @finally statement.
Definition: StmtObjC.h:154
clang::ObjCCategoryDecl::protocol_end
protocol_iterator protocol_end() const
Definition: DeclObjC.h:2364
clang::ObjCAtTryStmt::getNumCatchStmts
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
Definition: StmtObjC.h:203
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1566
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:276
clang::ObjCImplementationDecl::getName
StringRef getName() const
getName - Get the name of identifier for the class interface associated with this implementation as a...
Definition: DeclObjC.h:2673
clang::ObjCIvarDecl::Package
Definition: DeclObjC.h:1950
ObjCLabelType
ObjCLabelType
Definition: CGObjCMac.cpp:735
clang::CodeGen::RValue::get
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
clang::TagDecl::isUnion
bool isUnion() const
Definition: Decl.h:3252
clang::NamedDecl::getVisibility
Visibility getVisibility() const
Determines the visibility of this entity.
Definition: Decl.h:391
clang::CodeGen::NotForDefinition
Definition: CodeGenModule.h:99
clang::ast_matchers::blockDecl
const internal::VariadicDynCastAllOfMatcher< Decl, BlockDecl > blockDecl
Matches block declarations.
Definition: ASTMatchersInternal.cpp:641
clang::ObjCAtCatchStmt::getCatchParamDecl
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:94
clang::CodeGen::CodeGenFunction::EmitBranchThroughCleanup
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
Definition: CGCleanup.cpp:1050
clang::ASTContext::getTypeSizeInChars
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
Definition: ASTContext.cpp:2167
ConstantInitBuilder.h
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:648
clang::CodeGen::CGBuilderTy
Definition: CGBuilder.h:45
clang::LangOptions::ObjCConstantStringClass
std::string ObjCConstantStringClass
Definition: LangOptions.h:211
clang::CodeGen::LValue
LValue - This represents an lvalue references.
Definition: CGValue.h:167
clang::CodeGen::EHScopeStack::Cleanup
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:147
clang::ObjCPropertyDecl::getGetterMethodDecl
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:922
clang::CodeGen::CodeGenFunction::CGM
CodeGenModule & CGM
Definition: CodeGenFunction.h:258
clang::ObjCInterfaceDecl::all_declared_ivar_begin
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1592
clang::ASTContext::BoolTy
CanQualType BoolTy
Definition: ASTContext.h:1017
clang::ObjCIvarDecl::getAccessControl
AccessControl getAccessControl() const
Definition: DeclObjC.h:1984
clang::ObjCProtocolDecl::protocol_iterator
ObjCProtocolList::iterator protocol_iterator
Definition: DeclObjC.h:2126
clang::CodeGen::CallArgList
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:260
not
#define not
Definition: iso646.h:35
clang::ASTContext::getLangOpts
const LangOptions & getLangOpts() const
Definition: ASTContext.h:707
clang::CodeGen::CodeGenFunction::PopCleanupBlock
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
Definition: CGCleanup.cpp:651
clang::ObjCCategoryImplDecl
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2499
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2872
clang::CodeGen::ConstantArrayBuilder
A helper class of ConstantInitBuilder, used for building constant array initializers.
Definition: ConstantInitBuilder.h:526
clang::CodeGen::CGCalleeInfo
Abstract information about a function or function prototype.
Definition: CGCall.h:45
clang::CodeGen::RValue::isScalar
bool isScalar() const
Definition: CGValue.h:52
clang::CodeGen::CodeGenFunction::EmitNullInitialization
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
Definition: CodeGenFunction.cpp:1785
clang::ObjCMethodDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:367
clang::ObjCCompatibleAliasDecl
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2729
clang::Create
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
clang::ASTContext::getSizeType
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Definition: ASTContext.cpp:4958
clang::QualType::getObjCLifetime
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1058
clang::ObjCInterfaceDecl::FindCategoryDeclaration
ObjCCategoryDecl * FindCategoryDeclaration(IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
Definition: DeclObjC.cpp:1664
clang::CodeGen::CodeGenTypes::GetFunctionType
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1550
clang::CodeGen::CodeGenModule::getTriple
const llvm::Triple & getTriple() const
Definition: CodeGenModule.h:665