clang 10.0.0git

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