clang 17.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"
20#include "clang/AST/Attr.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/Mangle.h"
25#include "clang/AST/StmtObjC.h"
30#include "llvm/ADT/CachedHashString.h"
31#include "llvm/ADT/DenseSet.h"
32#include "llvm/ADT/SetVector.h"
33#include "llvm/ADT/SmallPtrSet.h"
34#include "llvm/ADT/SmallString.h"
35#include "llvm/ADT/UniqueVector.h"
36#include "llvm/IR/DataLayout.h"
37#include "llvm/IR/InlineAsm.h"
38#include "llvm/IR/IntrinsicInst.h"
39#include "llvm/IR/LLVMContext.h"
40#include "llvm/IR/Module.h"
41#include "llvm/Support/ScopedPrinter.h"
42#include "llvm/Support/raw_ostream.h"
43#include <cstdio>
44
45using namespace clang;
46using namespace CodeGen;
47
48namespace {
49
50// FIXME: We should find a nicer way to make the labels for metadata, string
51// concatenation is lame.
52
53class ObjCCommonTypesHelper {
54protected:
55 llvm::LLVMContext &VMContext;
56
57private:
58 // The types of these functions don't really matter because we
59 // should always bitcast before calling them.
60
61 /// id objc_msgSend (id, SEL, ...)
62 ///
63 /// The default messenger, used for sends whose ABI is unchanged from
64 /// the all-integer/pointer case.
65 llvm::FunctionCallee getMessageSendFn() const {
66 // Add the non-lazy-bind attribute, since objc_msgSend is likely to
67 // be called a lot.
68 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
69 return CGM.CreateRuntimeFunction(
70 llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
71 llvm::AttributeList::get(CGM.getLLVMContext(),
72 llvm::AttributeList::FunctionIndex,
73 llvm::Attribute::NonLazyBind));
74 }
75
76 /// void objc_msgSend_stret (id, SEL, ...)
77 ///
78 /// The messenger used when the return value is an aggregate returned
79 /// by indirect reference in the first argument, and therefore the
80 /// self and selector parameters are shifted over by one.
81 llvm::FunctionCallee getMessageSendStretFn() const {
82 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
83 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
84 params, true),
85 "objc_msgSend_stret");
86 }
87
88 /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
89 ///
90 /// The messenger used when the return value is returned on the x87
91 /// floating-point stack; without a special entrypoint, the nil case
92 /// would be unbalanced.
93 llvm::FunctionCallee getMessageSendFpretFn() const {
94 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
95 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
96 params, true),
97 "objc_msgSend_fpret");
98 }
99
100 /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
101 ///
102 /// The messenger used when the return value is returned in two values on the
103 /// x87 floating point stack; without a special entrypoint, the nil case
104 /// would be unbalanced. Only used on 64-bit X86.
105 llvm::FunctionCallee getMessageSendFp2retFn() const {
106 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
107 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
108 llvm::Type *resultType =
109 llvm::StructType::get(longDoubleType, longDoubleType);
110
111 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
112 params, true),
113 "objc_msgSend_fp2ret");
114 }
115
116 /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
117 ///
118 /// The messenger used for super calls, which have different dispatch
119 /// semantics. The class passed is the superclass of the current
120 /// class.
121 llvm::FunctionCallee getMessageSendSuperFn() const {
122 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
123 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
124 params, true),
125 "objc_msgSendSuper");
126 }
127
128 /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
129 ///
130 /// A slightly different messenger used for super calls. The class
131 /// passed is the current class.
132 llvm::FunctionCallee getMessageSendSuperFn2() const {
133 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
134 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
135 params, true),
136 "objc_msgSendSuper2");
137 }
138
139 /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
140 /// SEL op, ...)
141 ///
142 /// The messenger used for super calls which return an aggregate indirectly.
143 llvm::FunctionCallee getMessageSendSuperStretFn() const {
144 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
145 return CGM.CreateRuntimeFunction(
146 llvm::FunctionType::get(CGM.VoidTy, params, true),
147 "objc_msgSendSuper_stret");
148 }
149
150 /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
151 /// SEL op, ...)
152 ///
153 /// objc_msgSendSuper_stret with the super2 semantics.
154 llvm::FunctionCallee getMessageSendSuperStretFn2() const {
155 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
156 return CGM.CreateRuntimeFunction(
157 llvm::FunctionType::get(CGM.VoidTy, params, true),
158 "objc_msgSendSuper2_stret");
159 }
160
161 llvm::FunctionCallee getMessageSendSuperFpretFn() const {
162 // There is no objc_msgSendSuper_fpret? How can that work?
163 return getMessageSendSuperFn();
164 }
165
166 llvm::FunctionCallee getMessageSendSuperFpretFn2() const {
167 // There is no objc_msgSendSuper_fpret? How can that work?
168 return getMessageSendSuperFn2();
169 }
170
171protected:
173
174public:
175 llvm::IntegerType *ShortTy, *IntTy, *LongTy;
176 llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
177 llvm::PointerType *Int8PtrProgramASTy;
178 llvm::Type *IvarOffsetVarTy;
179
180 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
181 llvm::PointerType *ObjectPtrTy;
182
183 /// PtrObjectPtrTy - LLVM type for id *
184 llvm::PointerType *PtrObjectPtrTy;
185
186 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
187 llvm::PointerType *SelectorPtrTy;
188
189private:
190 /// ProtocolPtrTy - LLVM type for external protocol handles
191 /// (typeof(Protocol))
192 llvm::Type *ExternalProtocolPtrTy;
193
194public:
195 llvm::Type *getExternalProtocolPtrTy() {
196 if (!ExternalProtocolPtrTy) {
197 // FIXME: It would be nice to unify this with the opaque type, so that the
198 // IR comes out a bit cleaner.
199 CodeGen::CodeGenTypes &Types = CGM.getTypes();
200 ASTContext &Ctx = CGM.getContext();
201 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
202 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
203 }
204
205 return ExternalProtocolPtrTy;
206 }
207
208 // SuperCTy - clang type for struct objc_super.
209 QualType SuperCTy;
210 // SuperPtrCTy - clang type for struct objc_super *.
211 QualType SuperPtrCTy;
212
213 /// SuperTy - LLVM type for struct objc_super.
214 llvm::StructType *SuperTy;
215 /// SuperPtrTy - LLVM type for struct objc_super *.
216 llvm::PointerType *SuperPtrTy;
217
218 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
219 /// in GCC parlance).
220 llvm::StructType *PropertyTy;
221
222 /// PropertyListTy - LLVM type for struct objc_property_list
223 /// (_prop_list_t in GCC parlance).
224 llvm::StructType *PropertyListTy;
225 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
226 llvm::PointerType *PropertyListPtrTy;
227
228 // MethodTy - LLVM type for struct objc_method.
229 llvm::StructType *MethodTy;
230
231 /// CacheTy - LLVM type for struct objc_cache.
232 llvm::Type *CacheTy;
233 /// CachePtrTy - LLVM type for struct objc_cache *.
234 llvm::PointerType *CachePtrTy;
235
236 llvm::FunctionCallee getGetPropertyFn() {
237 CodeGen::CodeGenTypes &Types = CGM.getTypes();
238 ASTContext &Ctx = CGM.getContext();
239 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
242 CanQualType Params[] = {
243 IdType, SelType,
245 llvm::FunctionType *FTy =
246 Types.GetFunctionType(
247 Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
248 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
249 }
250
251 llvm::FunctionCallee getSetPropertyFn() {
252 CodeGen::CodeGenTypes &Types = CGM.getTypes();
253 ASTContext &Ctx = CGM.getContext();
254 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
257 CanQualType Params[] = {
258 IdType,
259 SelType,
261 IdType,
262 Ctx.BoolTy,
263 Ctx.BoolTy};
264 llvm::FunctionType *FTy =
265 Types.GetFunctionType(
266 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
267 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
268 }
269
270 llvm::FunctionCallee getOptimizedSetPropertyFn(bool atomic, bool copy) {
271 CodeGen::CodeGenTypes &Types = CGM.getTypes();
272 ASTContext &Ctx = CGM.getContext();
273 // void objc_setProperty_atomic(id self, SEL _cmd,
274 // id newValue, ptrdiff_t offset);
275 // void objc_setProperty_nonatomic(id self, SEL _cmd,
276 // id newValue, ptrdiff_t offset);
277 // void objc_setProperty_atomic_copy(id self, SEL _cmd,
278 // id newValue, ptrdiff_t offset);
279 // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
280 // id newValue, ptrdiff_t offset);
281
285 Params.push_back(IdType);
286 Params.push_back(SelType);
287 Params.push_back(IdType);
288 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
289 llvm::FunctionType *FTy =
290 Types.GetFunctionType(
291 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
292 const char *name;
293 if (atomic && copy)
294 name = "objc_setProperty_atomic_copy";
295 else if (atomic && !copy)
296 name = "objc_setProperty_atomic";
297 else if (!atomic && copy)
298 name = "objc_setProperty_nonatomic_copy";
299 else
300 name = "objc_setProperty_nonatomic";
301
302 return CGM.CreateRuntimeFunction(FTy, name);
303 }
304
305 llvm::FunctionCallee getCopyStructFn() {
306 CodeGen::CodeGenTypes &Types = CGM.getTypes();
307 ASTContext &Ctx = CGM.getContext();
308 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
310 Params.push_back(Ctx.VoidPtrTy);
311 Params.push_back(Ctx.VoidPtrTy);
312 Params.push_back(Ctx.getSizeType());
313 Params.push_back(Ctx.BoolTy);
314 Params.push_back(Ctx.BoolTy);
315 llvm::FunctionType *FTy =
316 Types.GetFunctionType(
317 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
318 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
319 }
320
321 /// This routine declares and returns address of:
322 /// void objc_copyCppObjectAtomic(
323 /// void *dest, const void *src,
324 /// void (*copyHelper) (void *dest, const void *source));
325 llvm::FunctionCallee getCppAtomicObjectFunction() {
326 CodeGen::CodeGenTypes &Types = CGM.getTypes();
327 ASTContext &Ctx = CGM.getContext();
328 /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
330 Params.push_back(Ctx.VoidPtrTy);
331 Params.push_back(Ctx.VoidPtrTy);
332 Params.push_back(Ctx.VoidPtrTy);
333 llvm::FunctionType *FTy =
334 Types.GetFunctionType(
335 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
336 return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
337 }
338
339 llvm::FunctionCallee getEnumerationMutationFn() {
340 CodeGen::CodeGenTypes &Types = CGM.getTypes();
341 ASTContext &Ctx = CGM.getContext();
342 // void objc_enumerationMutation (id)
344 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
345 llvm::FunctionType *FTy =
346 Types.GetFunctionType(
347 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
348 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
349 }
350
351 llvm::FunctionCallee getLookUpClassFn() {
352 CodeGen::CodeGenTypes &Types = CGM.getTypes();
353 ASTContext &Ctx = CGM.getContext();
354 // Class objc_lookUpClass (const char *)
356 Params.push_back(
358 llvm::FunctionType *FTy =
359 Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration(
361 Params));
362 return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
363 }
364
365 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
366 llvm::FunctionCallee getGcReadWeakFn() {
367 // id objc_read_weak (id *)
368 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
369 llvm::FunctionType *FTy =
370 llvm::FunctionType::get(ObjectPtrTy, args, false);
371 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
372 }
373
374 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
375 llvm::FunctionCallee getGcAssignWeakFn() {
376 // id objc_assign_weak (id, id *)
377 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
378 llvm::FunctionType *FTy =
379 llvm::FunctionType::get(ObjectPtrTy, args, false);
380 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
381 }
382
383 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
384 llvm::FunctionCallee getGcAssignGlobalFn() {
385 // id objc_assign_global(id, id *)
386 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
387 llvm::FunctionType *FTy =
388 llvm::FunctionType::get(ObjectPtrTy, args, false);
389 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
390 }
391
392 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
393 llvm::FunctionCallee getGcAssignThreadLocalFn() {
394 // id objc_assign_threadlocal(id src, id * dest)
395 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
396 llvm::FunctionType *FTy =
397 llvm::FunctionType::get(ObjectPtrTy, args, false);
398 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
399 }
400
401 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
402 llvm::FunctionCallee getGcAssignIvarFn() {
403 // id objc_assign_ivar(id, id *, ptrdiff_t)
404 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
405 CGM.PtrDiffTy };
406 llvm::FunctionType *FTy =
407 llvm::FunctionType::get(ObjectPtrTy, args, false);
408 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
409 }
410
411 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
412 llvm::FunctionCallee GcMemmoveCollectableFn() {
413 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
414 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
415 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
416 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
417 }
418
419 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
420 llvm::FunctionCallee getGcAssignStrongCastFn() {
421 // id objc_assign_strongCast(id, id *)
422 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
423 llvm::FunctionType *FTy =
424 llvm::FunctionType::get(ObjectPtrTy, args, false);
425 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
426 }
427
428 /// ExceptionThrowFn - LLVM objc_exception_throw function.
429 llvm::FunctionCallee getExceptionThrowFn() {
430 // void objc_exception_throw(id)
431 llvm::Type *args[] = { ObjectPtrTy };
432 llvm::FunctionType *FTy =
433 llvm::FunctionType::get(CGM.VoidTy, args, false);
434 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
435 }
436
437 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
438 llvm::FunctionCallee getExceptionRethrowFn() {
439 // void objc_exception_rethrow(void)
440 llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
441 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
442 }
443
444 /// SyncEnterFn - LLVM object_sync_enter function.
445 llvm::FunctionCallee getSyncEnterFn() {
446 // int objc_sync_enter (id)
447 llvm::Type *args[] = { ObjectPtrTy };
448 llvm::FunctionType *FTy =
449 llvm::FunctionType::get(CGM.IntTy, args, false);
450 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
451 }
452
453 /// SyncExitFn - LLVM object_sync_exit function.
454 llvm::FunctionCallee getSyncExitFn() {
455 // int objc_sync_exit (id)
456 llvm::Type *args[] = { ObjectPtrTy };
457 llvm::FunctionType *FTy =
458 llvm::FunctionType::get(CGM.IntTy, args, false);
459 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
460 }
461
462 llvm::FunctionCallee getSendFn(bool IsSuper) const {
463 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
464 }
465
466 llvm::FunctionCallee getSendFn2(bool IsSuper) const {
467 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
468 }
469
470 llvm::FunctionCallee getSendStretFn(bool IsSuper) const {
471 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
472 }
473
474 llvm::FunctionCallee getSendStretFn2(bool IsSuper) const {
475 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
476 }
477
478 llvm::FunctionCallee getSendFpretFn(bool IsSuper) const {
479 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
480 }
481
482 llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const {
483 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
484 }
485
486 llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const {
487 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
488 }
489
490 llvm::FunctionCallee getSendFp2RetFn2(bool IsSuper) const {
491 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
492 }
493
494 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
495};
496
497/// ObjCTypesHelper - Helper class that encapsulates lazy
498/// construction of varies types used during ObjC generation.
499class ObjCTypesHelper : public ObjCCommonTypesHelper {
500public:
501 /// SymtabTy - LLVM type for struct objc_symtab.
502 llvm::StructType *SymtabTy;
503 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
504 llvm::PointerType *SymtabPtrTy;
505 /// ModuleTy - LLVM type for struct objc_module.
506 llvm::StructType *ModuleTy;
507
508 /// ProtocolTy - LLVM type for struct objc_protocol.
509 llvm::StructType *ProtocolTy;
510 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
511 llvm::PointerType *ProtocolPtrTy;
512 /// ProtocolExtensionTy - LLVM type for struct
513 /// objc_protocol_extension.
514 llvm::StructType *ProtocolExtensionTy;
515 /// ProtocolExtensionTy - LLVM type for struct
516 /// objc_protocol_extension *.
517 llvm::PointerType *ProtocolExtensionPtrTy;
518 /// MethodDescriptionTy - LLVM type for struct
519 /// objc_method_description.
520 llvm::StructType *MethodDescriptionTy;
521 /// MethodDescriptionListTy - LLVM type for struct
522 /// objc_method_description_list.
523 llvm::StructType *MethodDescriptionListTy;
524 /// MethodDescriptionListPtrTy - LLVM type for struct
525 /// objc_method_description_list *.
526 llvm::PointerType *MethodDescriptionListPtrTy;
527 /// ProtocolListTy - LLVM type for struct objc_property_list.
528 llvm::StructType *ProtocolListTy;
529 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
530 llvm::PointerType *ProtocolListPtrTy;
531 /// CategoryTy - LLVM type for struct objc_category.
532 llvm::StructType *CategoryTy;
533 /// ClassTy - LLVM type for struct objc_class.
534 llvm::StructType *ClassTy;
535 /// ClassPtrTy - LLVM type for struct objc_class *.
536 llvm::PointerType *ClassPtrTy;
537 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
538 llvm::StructType *ClassExtensionTy;
539 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
540 llvm::PointerType *ClassExtensionPtrTy;
541 // IvarTy - LLVM type for struct objc_ivar.
542 llvm::StructType *IvarTy;
543 /// IvarListTy - LLVM type for struct objc_ivar_list.
544 llvm::StructType *IvarListTy;
545 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
546 llvm::PointerType *IvarListPtrTy;
547 /// MethodListTy - LLVM type for struct objc_method_list.
548 llvm::StructType *MethodListTy;
549 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
550 llvm::PointerType *MethodListPtrTy;
551
552 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
553 llvm::StructType *ExceptionDataTy;
554
555 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
556 llvm::FunctionCallee getExceptionTryEnterFn() {
557 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
558 return CGM.CreateRuntimeFunction(
559 llvm::FunctionType::get(CGM.VoidTy, params, false),
560 "objc_exception_try_enter");
561 }
562
563 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
564 llvm::FunctionCallee getExceptionTryExitFn() {
565 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
566 return CGM.CreateRuntimeFunction(
567 llvm::FunctionType::get(CGM.VoidTy, params, false),
568 "objc_exception_try_exit");
569 }
570
571 /// ExceptionExtractFn - LLVM objc_exception_extract function.
572 llvm::FunctionCallee getExceptionExtractFn() {
573 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
574 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
575 params, false),
576 "objc_exception_extract");
577 }
578
579 /// ExceptionMatchFn - LLVM objc_exception_match function.
580 llvm::FunctionCallee getExceptionMatchFn() {
581 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
582 return CGM.CreateRuntimeFunction(
583 llvm::FunctionType::get(CGM.Int32Ty, params, false),
584 "objc_exception_match");
585 }
586
587 /// SetJmpFn - LLVM _setjmp function.
588 llvm::FunctionCallee getSetJmpFn() {
589 // This is specifically the prototype for x86.
590 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
591 return CGM.CreateRuntimeFunction(
592 llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp",
593 llvm::AttributeList::get(CGM.getLLVMContext(),
594 llvm::AttributeList::FunctionIndex,
595 llvm::Attribute::NonLazyBind));
596 }
597
598public:
599 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
600};
601
602/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
603/// modern abi
604class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
605public:
606 // MethodListnfABITy - LLVM for struct _method_list_t
607 llvm::StructType *MethodListnfABITy;
608
609 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
610 llvm::PointerType *MethodListnfABIPtrTy;
611
612 // ProtocolnfABITy = LLVM for struct _protocol_t
613 llvm::StructType *ProtocolnfABITy;
614
615 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
616 llvm::PointerType *ProtocolnfABIPtrTy;
617
618 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
619 llvm::StructType *ProtocolListnfABITy;
620
621 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
622 llvm::PointerType *ProtocolListnfABIPtrTy;
623
624 // ClassnfABITy - LLVM for struct _class_t
625 llvm::StructType *ClassnfABITy;
626
627 // ClassnfABIPtrTy - LLVM for struct _class_t*
628 llvm::PointerType *ClassnfABIPtrTy;
629
630 // IvarnfABITy - LLVM for struct _ivar_t
631 llvm::StructType *IvarnfABITy;
632
633 // IvarListnfABITy - LLVM for struct _ivar_list_t
634 llvm::StructType *IvarListnfABITy;
635
636 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
637 llvm::PointerType *IvarListnfABIPtrTy;
638
639 // ClassRonfABITy - LLVM for struct _class_ro_t
640 llvm::StructType *ClassRonfABITy;
641
642 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
643 llvm::PointerType *ImpnfABITy;
644
645 // CategorynfABITy - LLVM for struct _category_t
646 llvm::StructType *CategorynfABITy;
647
648 // New types for nonfragile abi messaging.
649
650 // MessageRefTy - LLVM for:
651 // struct _message_ref_t {
652 // IMP messenger;
653 // SEL name;
654 // };
655 llvm::StructType *MessageRefTy;
656 // MessageRefCTy - clang type for struct _message_ref_t
657 QualType MessageRefCTy;
658
659 // MessageRefPtrTy - LLVM for struct _message_ref_t*
660 llvm::Type *MessageRefPtrTy;
661 // MessageRefCPtrTy - clang type for struct _message_ref_t*
662 QualType MessageRefCPtrTy;
663
664 // SuperMessageRefTy - LLVM for:
665 // struct _super_message_ref_t {
666 // SUPER_IMP messenger;
667 // SEL name;
668 // };
669 llvm::StructType *SuperMessageRefTy;
670
671 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
672 llvm::PointerType *SuperMessageRefPtrTy;
673
674 llvm::FunctionCallee getMessageSendFixupFn() {
675 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
676 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
677 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
678 params, true),
679 "objc_msgSend_fixup");
680 }
681
682 llvm::FunctionCallee getMessageSendFpretFixupFn() {
683 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
684 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
685 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
686 params, true),
687 "objc_msgSend_fpret_fixup");
688 }
689
690 llvm::FunctionCallee getMessageSendStretFixupFn() {
691 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
692 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
693 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
694 params, true),
695 "objc_msgSend_stret_fixup");
696 }
697
698 llvm::FunctionCallee getMessageSendSuper2FixupFn() {
699 // id objc_msgSendSuper2_fixup (struct objc_super *,
700 // struct _super_message_ref_t*, ...)
701 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
702 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
703 params, true),
704 "objc_msgSendSuper2_fixup");
705 }
706
707 llvm::FunctionCallee getMessageSendSuper2StretFixupFn() {
708 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
709 // struct _super_message_ref_t*, ...)
710 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
711 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
712 params, true),
713 "objc_msgSendSuper2_stret_fixup");
714 }
715
716 llvm::FunctionCallee getObjCEndCatchFn() {
717 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
718 "objc_end_catch");
719 }
720
721 llvm::FunctionCallee getObjCBeginCatchFn() {
722 llvm::Type *params[] = { Int8PtrTy };
723 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
724 params, false),
725 "objc_begin_catch");
726 }
727
728 /// Class objc_loadClassref (void *)
729 ///
730 /// Loads from a classref. For Objective-C stub classes, this invokes the
731 /// initialization callback stored inside the stub. For all other classes
732 /// this simply dereferences the pointer.
733 llvm::FunctionCallee getLoadClassrefFn() const {
734 // Add the non-lazy-bind attribute, since objc_loadClassref is likely to
735 // be called a lot.
736 //
737 // Also it is safe to make it readnone, since we never load or store the
738 // classref except by calling this function.
739 llvm::Type *params[] = { Int8PtrPtrTy };
740 llvm::LLVMContext &C = CGM.getLLVMContext();
741 llvm::AttributeSet AS = llvm::AttributeSet::get(C, {
742 llvm::Attribute::get(C, llvm::Attribute::NonLazyBind),
743 llvm::Attribute::getWithMemoryEffects(C, llvm::MemoryEffects::none()),
744 llvm::Attribute::get(C, llvm::Attribute::NoUnwind),
745 });
746 llvm::FunctionCallee F = CGM.CreateRuntimeFunction(
747 llvm::FunctionType::get(ClassnfABIPtrTy, params, false),
748 "objc_loadClassref",
749 llvm::AttributeList::get(CGM.getLLVMContext(),
750 llvm::AttributeList::FunctionIndex, AS));
751 if (!CGM.getTriple().isOSBinFormatCOFF())
752 cast<llvm::Function>(F.getCallee())->setLinkage(
753 llvm::Function::ExternalWeakLinkage);
754
755 return F;
756 }
757
758 llvm::StructType *EHTypeTy;
759 llvm::Type *EHTypePtrTy;
760
761 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
762};
763
764enum class ObjCLabelType {
765 ClassName,
766 MethodVarName,
767 MethodVarType,
768 PropertyName,
769};
770
771class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
772public:
773 class SKIP_SCAN {
774 public:
775 unsigned skip;
776 unsigned scan;
777 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
778 : skip(_skip), scan(_scan) {}
779 };
780
781 /// opcode for captured block variables layout 'instructions'.
782 /// In the following descriptions, 'I' is the value of the immediate field.
783 /// (field following the opcode).
784 ///
785 enum BLOCK_LAYOUT_OPCODE {
786 /// An operator which affects how the following layout should be
787 /// interpreted.
788 /// I == 0: Halt interpretation and treat everything else as
789 /// a non-pointer. Note that this instruction is equal
790 /// to '\0'.
791 /// I != 0: Currently unused.
792 BLOCK_LAYOUT_OPERATOR = 0,
793
794 /// The next I+1 bytes do not contain a value of object pointer type.
795 /// Note that this can leave the stream unaligned, meaning that
796 /// subsequent word-size instructions do not begin at a multiple of
797 /// the pointer size.
798 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
799
800 /// The next I+1 words do not contain a value of object pointer type.
801 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
802 /// when the required skip quantity is a multiple of the pointer size.
803 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
804
805 /// The next I+1 words are __strong pointers to Objective-C
806 /// objects or blocks.
807 BLOCK_LAYOUT_STRONG = 3,
808
809 /// The next I+1 words are pointers to __block variables.
810 BLOCK_LAYOUT_BYREF = 4,
811
812 /// The next I+1 words are __weak pointers to Objective-C
813 /// objects or blocks.
814 BLOCK_LAYOUT_WEAK = 5,
815
816 /// The next I+1 words are __unsafe_unretained pointers to
817 /// Objective-C objects or blocks.
818 BLOCK_LAYOUT_UNRETAINED = 6
819
820 /// The next I+1 words are block or object pointers with some
821 /// as-yet-unspecified ownership semantics. If we add more
822 /// flavors of ownership semantics, values will be taken from
823 /// this range.
824 ///
825 /// This is included so that older tools can at least continue
826 /// processing the layout past such things.
827 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
828
829 /// All other opcodes are reserved. Halt interpretation and
830 /// treat everything else as opaque.
831 };
832
833 class RUN_SKIP {
834 public:
835 enum BLOCK_LAYOUT_OPCODE opcode;
836 CharUnits block_var_bytepos;
837 CharUnits block_var_size;
838 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
839 CharUnits BytePos = CharUnits::Zero(),
840 CharUnits Size = CharUnits::Zero())
841 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
842
843 // Allow sorting based on byte pos.
844 bool operator<(const RUN_SKIP &b) const {
845 return block_var_bytepos < b.block_var_bytepos;
846 }
847 };
848
849protected:
850 llvm::LLVMContext &VMContext;
851 // FIXME! May not be needing this after all.
852 unsigned ObjCABI;
853
854 // arc/mrr layout of captured block literal variables.
855 SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
856
857 /// LazySymbols - Symbols to generate a lazy reference for. See
858 /// DefinedSymbols and FinishModule().
859 llvm::SetVector<IdentifierInfo*> LazySymbols;
860
861 /// DefinedSymbols - External symbols which are defined by this
862 /// module. The symbols in this list and LazySymbols are used to add
863 /// special linker symbols which ensure that Objective-C modules are
864 /// linked properly.
865 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
866
867 /// ClassNames - uniqued class names.
868 llvm::StringMap<llvm::GlobalVariable*> ClassNames;
869
870 /// MethodVarNames - uniqued method variable names.
871 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
872
873 /// DefinedCategoryNames - list of category names in form Class_Category.
875
876 /// MethodVarTypes - uniqued method type signatures. We have to use
877 /// a StringMap here because have no other unique reference.
878 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
879
880 /// MethodDefinitions - map of methods which have been defined in
881 /// this translation unit.
882 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
883
884 /// DirectMethodDefinitions - map of direct methods which have been defined in
885 /// this translation unit.
886 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> DirectMethodDefinitions;
887
888 /// PropertyNames - uniqued method variable names.
889 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
890
891 /// ClassReferences - uniqued class references.
892 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
893
894 /// SelectorReferences - uniqued selector references.
895 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
896
897 /// Protocols - Protocols for which an objc_protocol structure has
898 /// been emitted. Forward declarations are handled by creating an
899 /// empty structure whose initializer is filled in when/if defined.
900 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
901
902 /// DefinedProtocols - Protocols which have actually been
903 /// defined. We should not need this, see FIXME in GenerateProtocol.
904 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
905
906 /// DefinedClasses - List of defined classes.
908
909 /// ImplementedClasses - List of @implemented classes.
911
912 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
913 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
914
915 /// DefinedCategories - List of defined categories.
916 SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
917
918 /// DefinedStubCategories - List of defined categories on class stubs.
919 SmallVector<llvm::GlobalValue*, 16> DefinedStubCategories;
920
921 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
922 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
923
924 /// Cached reference to the class for constant strings. This value has type
925 /// int * but is actually an Obj-C class pointer.
926 llvm::WeakTrackingVH ConstantStringClassRef;
927
928 /// The LLVM type corresponding to NSConstantString.
929 llvm::StructType *NSConstantStringType = nullptr;
930
931 llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;
932
933 /// GetMethodVarName - Return a unique constant for the given
934 /// selector's name. The return value has type char *.
935 llvm::Constant *GetMethodVarName(Selector Sel);
936 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
937
938 /// GetMethodVarType - Return a unique constant for the given
939 /// method's type encoding string. The return value has type char *.
940
941 // FIXME: This is a horrible name.
942 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
943 bool Extended = false);
944 llvm::Constant *GetMethodVarType(const FieldDecl *D);
945
946 /// GetPropertyName - Return a unique constant for the given
947 /// name. The return value has type char *.
948 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
949
950 // FIXME: This can be dropped once string functions are unified.
951 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
952 const Decl *Container);
953
954 /// GetClassName - Return a unique constant for the given selector's
955 /// runtime name (which may change via use of objc_runtime_name attribute on
956 /// class or protocol definition. The return value has type char *.
957 llvm::Constant *GetClassName(StringRef RuntimeName);
958
959 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
960
961 /// BuildIvarLayout - Builds ivar layout bitmap for the class
962 /// implementation for the __strong or __weak case.
963 ///
964 /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
965 /// are any weak ivars defined directly in the class. Meaningless unless
966 /// building a weak layout. Does not guarantee that the layout will
967 /// actually have any entries, because the ivar might be under-aligned.
968 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
969 CharUnits beginOffset,
970 CharUnits endOffset,
971 bool forStrongLayout,
972 bool hasMRCWeakIvars);
973
974 llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
975 CharUnits beginOffset,
976 CharUnits endOffset) {
977 return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
978 }
979
980 llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
981 CharUnits beginOffset,
982 CharUnits endOffset,
983 bool hasMRCWeakIvars) {
984 return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
985 }
986
987 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
988
989 void UpdateRunSkipBlockVars(bool IsByref,
991 CharUnits FieldOffset,
992 CharUnits FieldSize);
993
994 void BuildRCBlockVarRecordLayout(const RecordType *RT,
995 CharUnits BytePos, bool &HasUnion,
996 bool ByrefLayout=false);
997
998 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
999 const RecordDecl *RD,
1001 CharUnits BytePos, bool &HasUnion,
1002 bool ByrefLayout);
1003
1004 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
1005
1006 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
1007
1008 /// GetIvarLayoutName - Returns a unique constant for the given
1009 /// ivar layout bitmap.
1010 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
1011 const ObjCCommonTypesHelper &ObjCTypes);
1012
1013 /// EmitPropertyList - Emit the given property list. The return
1014 /// value has type PropertyListPtrTy.
1015 llvm::Constant *EmitPropertyList(Twine Name,
1016 const Decl *Container,
1017 const ObjCContainerDecl *OCD,
1018 const ObjCCommonTypesHelper &ObjCTypes,
1019 bool IsClassProperty);
1020
1021 /// EmitProtocolMethodTypes - Generate the array of extended method type
1022 /// strings. The return value has type Int8PtrPtrTy.
1023 llvm::Constant *EmitProtocolMethodTypes(Twine Name,
1024 ArrayRef<llvm::Constant*> MethodTypes,
1025 const ObjCCommonTypesHelper &ObjCTypes);
1026
1027 /// GetProtocolRef - Return a reference to the internal protocol
1028 /// description, creating an empty one if it has not been
1029 /// defined. The return value has type ProtocolPtrTy.
1030 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1031
1032 /// Return a reference to the given Class using runtime calls rather than
1033 /// by a symbol reference.
1034 llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1035 const ObjCInterfaceDecl *ID,
1036 ObjCCommonTypesHelper &ObjCTypes);
1037
1038 std::string GetSectionName(StringRef Section, StringRef MachOAttributes);
1039
1040public:
1041 /// CreateMetadataVar - Create a global variable with internal
1042 /// linkage for use by the Objective-C runtime.
1043 ///
1044 /// This is a convenience wrapper which not only creates the
1045 /// variable, but also sets the section and alignment and adds the
1046 /// global to the "llvm.used" list.
1047 ///
1048 /// \param Name - The variable name.
1049 /// \param Init - The variable initializer; this is also used to
1050 /// define the type of the variable.
1051 /// \param Section - The section the variable should go into, or empty.
1052 /// \param Align - The alignment for the variable, or 0.
1053 /// \param AddToUsed - Whether the variable should be added to
1054 /// "llvm.used".
1055 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1057 StringRef Section, CharUnits Align,
1058 bool AddToUsed);
1059 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1060 llvm::Constant *Init,
1061 StringRef Section, CharUnits Align,
1062 bool AddToUsed);
1063
1064 llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
1065 ObjCLabelType LabelType,
1066 bool ForceNonFragileABI = false,
1067 bool NullTerminate = true);
1068
1069protected:
1070 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1071 ReturnValueSlot Return,
1072 QualType ResultType,
1073 Selector Sel,
1074 llvm::Value *Arg0,
1075 QualType Arg0Ty,
1076 bool IsSuper,
1077 const CallArgList &CallArgs,
1078 const ObjCMethodDecl *OMD,
1079 const ObjCInterfaceDecl *ClassReceiver,
1080 const ObjCCommonTypesHelper &ObjCTypes);
1081
1082 /// EmitImageInfo - Emit the image info marker used to encode some module
1083 /// level information.
1084 void EmitImageInfo();
1085
1086public:
1087 CGObjCCommonMac(CodeGen::CodeGenModule &cgm)
1088 : CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) {}
1089
1090 bool isNonFragileABI() const {
1091 return ObjCABI == 2;
1092 }
1093
1095 ConstantAddress GenerateConstantNSString(const StringLiteral *SL);
1096
1097 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1098 const ObjCContainerDecl *CD=nullptr) override;
1099
1100 llvm::Function *GenerateDirectMethod(const ObjCMethodDecl *OMD,
1101 const ObjCContainerDecl *CD);
1102
1103 void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
1104 const ObjCMethodDecl *OMD,
1105 const ObjCContainerDecl *CD) override;
1106
1107 void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1108
1109 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1110 /// object for the given declaration, emitting it if needed. These
1111 /// forward references will be filled in with empty bodies if no
1112 /// definition is seen. The return value has type ProtocolPtrTy.
1113 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1114
1115 virtual llvm::Constant *getNSConstantStringClassRef() = 0;
1116
1117 llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1118 const CGBlockInfo &blockInfo) override;
1119 llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1120 const CGBlockInfo &blockInfo) override;
1122 const CGBlockInfo &blockInfo) override;
1123
1124 llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1125 QualType T) override;
1126
1127private:
1128 void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo);
1129};
1130
1131namespace {
1132
1133enum class MethodListType {
1134 CategoryInstanceMethods,
1135 CategoryClassMethods,
1136 InstanceMethods,
1137 ClassMethods,
1138 ProtocolInstanceMethods,
1139 ProtocolClassMethods,
1140 OptionalProtocolInstanceMethods,
1141 OptionalProtocolClassMethods,
1142};
1143
1144/// A convenience class for splitting the methods of a protocol into
1145/// the four interesting groups.
1146class ProtocolMethodLists {
1147public:
1148 enum Kind {
1149 RequiredInstanceMethods,
1150 RequiredClassMethods,
1151 OptionalInstanceMethods,
1152 OptionalClassMethods
1153 };
1154 enum {
1155 NumProtocolMethodLists = 4
1156 };
1157
1158 static MethodListType getMethodListKind(Kind kind) {
1159 switch (kind) {
1160 case RequiredInstanceMethods:
1161 return MethodListType::ProtocolInstanceMethods;
1162 case RequiredClassMethods:
1163 return MethodListType::ProtocolClassMethods;
1164 case OptionalInstanceMethods:
1165 return MethodListType::OptionalProtocolInstanceMethods;
1166 case OptionalClassMethods:
1167 return MethodListType::OptionalProtocolClassMethods;
1168 }
1169 llvm_unreachable("bad kind");
1170 }
1171
1172 SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];
1173
1174 static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
1175 ProtocolMethodLists result;
1176
1177 for (auto *MD : PD->methods()) {
1178 size_t index = (2 * size_t(MD->isOptional()))
1179 + (size_t(MD->isClassMethod()));
1180 result.Methods[index].push_back(MD);
1181 }
1182
1183 return result;
1184 }
1185
1186 template <class Self>
1187 SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
1188 // In both ABIs, the method types list is parallel with the
1189 // concatenation of the methods arrays in the following order:
1190 // instance methods
1191 // class methods
1192 // optional instance methods
1193 // optional class methods
1195
1196 // Methods is already in the correct order for both ABIs.
1197 for (auto &list : Methods) {
1198 for (auto MD : list) {
1199 result.push_back(self->GetMethodVarType(MD, true));
1200 }
1201 }
1202
1203 return result;
1204 }
1205
1206 template <class Self>
1207 llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
1208 Kind kind) const {
1209 return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
1210 getMethodListKind(kind), Methods[kind]);
1211 }
1212};
1213
1214} // end anonymous namespace
1215
1216class CGObjCMac : public CGObjCCommonMac {
1217private:
1218 friend ProtocolMethodLists;
1219
1220 ObjCTypesHelper ObjCTypes;
1221
1222 /// EmitModuleInfo - Another marker encoding module level
1223 /// information.
1224 void EmitModuleInfo();
1225
1226 /// EmitModuleSymols - Emit module symbols, the list of defined
1227 /// classes and categories. The result has type SymtabPtrTy.
1228 llvm::Constant *EmitModuleSymbols();
1229
1230 /// FinishModule - Write out global data structures at the end of
1231 /// processing a translation unit.
1232 void FinishModule();
1233
1234 /// EmitClassExtension - Generate the class extension structure used
1235 /// to store the weak ivar layout and properties. The return value
1236 /// has type ClassExtensionPtrTy.
1237 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1238 CharUnits instanceSize,
1239 bool hasMRCWeakIvars,
1240 bool isMetaclass);
1241
1242 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1243 /// for the given class.
1244 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1245 const ObjCInterfaceDecl *ID);
1246
1247 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1248 IdentifierInfo *II);
1249
1250 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1251
1252 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1253 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1254
1255 /// EmitIvarList - Emit the ivar list for the given
1256 /// implementation. If ForClass is true the list of class ivars
1257 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1258 /// interface ivars will be emitted. The return value has type
1259 /// IvarListPtrTy.
1260 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1261 bool ForClass);
1262
1263 /// EmitMetaClass - Emit a forward reference to the class structure
1264 /// for the metaclass of the given interface. The return value has
1265 /// type ClassPtrTy.
1266 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1267
1268 /// EmitMetaClass - Emit a class structure for the metaclass of the
1269 /// given implementation. The return value has type ClassPtrTy.
1270 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1271 llvm::Constant *Protocols,
1273
1274 void emitMethodConstant(ConstantArrayBuilder &builder,
1275 const ObjCMethodDecl *MD);
1276
1277 void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
1278 const ObjCMethodDecl *MD);
1279
1280 /// EmitMethodList - Emit the method list for the given
1281 /// implementation. The return value has type MethodListPtrTy.
1282 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1284
1285 /// GetOrEmitProtocol - Get the protocol object for the given
1286 /// declaration, emitting it if necessary. The return value has type
1287 /// ProtocolPtrTy.
1288 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1289
1290 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1291 /// object for the given declaration, emitting it if needed. These
1292 /// forward references will be filled in with empty bodies if no
1293 /// definition is seen. The return value has type ProtocolPtrTy.
1294 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1295
1296 /// EmitProtocolExtension - Generate the protocol extension
1297 /// structure used to store optional instance and class methods, and
1298 /// protocol properties. The return value has type
1299 /// ProtocolExtensionPtrTy.
1300 llvm::Constant *
1301 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1302 const ProtocolMethodLists &methodLists);
1303
1304 /// EmitProtocolList - Generate the list of referenced
1305 /// protocols. The return value has type ProtocolListPtrTy.
1306 llvm::Constant *EmitProtocolList(Twine Name,
1309
1310 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1311 /// for the given selector.
1312 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1313 Address EmitSelectorAddr(Selector Sel);
1314
1315public:
1316 CGObjCMac(CodeGen::CodeGenModule &cgm);
1317
1318 llvm::Constant *getNSConstantStringClassRef() override;
1319
1320 llvm::Function *ModuleInitFunction() override;
1321
1322 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1323 ReturnValueSlot Return,
1324 QualType ResultType,
1325 Selector Sel, llvm::Value *Receiver,
1326 const CallArgList &CallArgs,
1327 const ObjCInterfaceDecl *Class,
1328 const ObjCMethodDecl *Method) override;
1329
1331 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1332 ReturnValueSlot Return, QualType ResultType,
1333 Selector Sel, const ObjCInterfaceDecl *Class,
1334 bool isCategoryImpl, llvm::Value *Receiver,
1335 bool IsClassMessage, const CallArgList &CallArgs,
1336 const ObjCMethodDecl *Method) override;
1337
1338 llvm::Value *GetClass(CodeGenFunction &CGF,
1339 const ObjCInterfaceDecl *ID) override;
1340
1341 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1342 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1343
1344 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1345 /// untyped one.
1346 llvm::Value *GetSelector(CodeGenFunction &CGF,
1347 const ObjCMethodDecl *Method) override;
1348
1349 llvm::Constant *GetEHType(QualType T) override;
1350
1351 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1352
1353 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1354
1355 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1356
1357 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1358 const ObjCProtocolDecl *PD) override;
1359
1360 llvm::FunctionCallee GetPropertyGetFunction() override;
1361 llvm::FunctionCallee GetPropertySetFunction() override;
1362 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
1363 bool copy) override;
1364 llvm::FunctionCallee GetGetStructFunction() override;
1365 llvm::FunctionCallee GetSetStructFunction() override;
1366 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
1367 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
1368 llvm::FunctionCallee EnumerationMutationFunction() override;
1369
1370 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1371 const ObjCAtTryStmt &S) override;
1372 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1373 const ObjCAtSynchronizedStmt &S) override;
1374 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1375 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1376 bool ClearInsertionPoint=true) override;
1377 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1378 Address AddrWeakObj) override;
1379 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1380 llvm::Value *src, Address dst) override;
1381 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1382 llvm::Value *src, Address dest,
1383 bool threadlocal = false) override;
1384 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1385 llvm::Value *src, Address dest,
1386 llvm::Value *ivarOffset) override;
1387 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1388 llvm::Value *src, Address dest) override;
1389 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1390 Address dest, Address src,
1391 llvm::Value *size) override;
1392
1393 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1394 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1395 unsigned CVRQualifiers) override;
1396 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1397 const ObjCInterfaceDecl *Interface,
1398 const ObjCIvarDecl *Ivar) override;
1399};
1400
1401class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1402private:
1403 friend ProtocolMethodLists;
1404 ObjCNonFragileABITypesHelper ObjCTypes;
1405 llvm::GlobalVariable* ObjCEmptyCacheVar;
1406 llvm::Constant* ObjCEmptyVtableVar;
1407
1408 /// SuperClassReferences - uniqued super class references.
1409 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1410
1411 /// MetaClassReferences - uniqued meta class references.
1412 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1413
1414 /// EHTypeReferences - uniqued class ehtype references.
1415 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1416
1417 /// VTableDispatchMethods - List of methods for which we generate
1418 /// vtable-based message dispatch.
1419 llvm::DenseSet<Selector> VTableDispatchMethods;
1420
1421 /// DefinedMetaClasses - List of defined meta-classes.
1422 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1423
1424 /// isVTableDispatchedSelector - Returns true if SEL is a
1425 /// vtable-based selector.
1426 bool isVTableDispatchedSelector(Selector Sel);
1427
1428 /// FinishNonFragileABIModule - Write out global data structures at the end of
1429 /// processing a translation unit.
1430 void FinishNonFragileABIModule();
1431
1432 /// AddModuleClassList - Add the given list of class pointers to the
1433 /// module with the provided symbol and section names.
1434 void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1435 StringRef SymbolName, StringRef SectionName);
1436
1437 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1438 unsigned InstanceStart,
1439 unsigned InstanceSize,
1440 const ObjCImplementationDecl *ID);
1441 llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
1442 bool isMetaclass,
1443 llvm::Constant *IsAGV,
1444 llvm::Constant *SuperClassGV,
1445 llvm::Constant *ClassRoGV,
1446 bool HiddenVisibility);
1447
1448 void emitMethodConstant(ConstantArrayBuilder &builder,
1449 const ObjCMethodDecl *MD,
1450 bool forProtocol);
1451
1452 /// Emit the method list for the given implementation. The return value
1453 /// has type MethodListnfABITy.
1454 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1456
1457 /// EmitIvarList - Emit the ivar list for the given
1458 /// implementation. If ForClass is true the list of class ivars
1459 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1460 /// interface ivars will be emitted. The return value has type
1461 /// IvarListnfABIPtrTy.
1462 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1463
1464 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1465 const ObjCIvarDecl *Ivar,
1466 unsigned long int offset);
1467
1468 /// GetOrEmitProtocol - Get the protocol object for the given
1469 /// declaration, emitting it if necessary. The return value has type
1470 /// ProtocolPtrTy.
1471 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1472
1473 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1474 /// object for the given declaration, emitting it if needed. These
1475 /// forward references will be filled in with empty bodies if no
1476 /// definition is seen. The return value has type ProtocolPtrTy.
1477 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1478
1479 /// EmitProtocolList - Generate the list of referenced
1480 /// protocols. The return value has type ProtocolListPtrTy.
1481 llvm::Constant *EmitProtocolList(Twine Name,
1484
1485 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1486 ReturnValueSlot Return,
1487 QualType ResultType,
1488 Selector Sel,
1489 llvm::Value *Receiver,
1490 QualType Arg0Ty,
1491 bool IsSuper,
1492 const CallArgList &CallArgs,
1493 const ObjCMethodDecl *Method);
1494
1495 /// GetClassGlobal - Return the global variable for the Objective-C
1496 /// class of the given name.
1497 llvm::Constant *GetClassGlobal(StringRef Name,
1498 ForDefinition_t IsForDefinition,
1499 bool Weak = false, bool DLLImport = false);
1500 llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
1501 bool isMetaclass,
1502 ForDefinition_t isForDefinition);
1503
1504 llvm::Constant *GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID);
1505
1506 llvm::Value *EmitLoadOfClassRef(CodeGenFunction &CGF,
1507 const ObjCInterfaceDecl *ID,
1508 llvm::GlobalVariable *Entry);
1509
1510 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1511 /// for the given class reference.
1512 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1513 const ObjCInterfaceDecl *ID);
1514
1515 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1516 IdentifierInfo *II,
1517 const ObjCInterfaceDecl *ID);
1518
1519 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1520
1521 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1522 /// for the given super class reference.
1523 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1524 const ObjCInterfaceDecl *ID);
1525
1526 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1527 /// meta-data
1528 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1529 const ObjCInterfaceDecl *ID, bool Weak);
1530
1531 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1532 /// the given ivar.
1533 ///
1534 llvm::GlobalVariable * ObjCIvarOffsetVariable(
1535 const ObjCInterfaceDecl *ID,
1536 const ObjCIvarDecl *Ivar);
1537
1538 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1539 /// for the given selector.
1540 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1541 Address EmitSelectorAddr(Selector Sel);
1542
1543 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1544 /// interface. The return value has type EHTypePtrTy.
1545 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1546 ForDefinition_t IsForDefinition);
1547
1548 StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1549
1550 StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1551
1552 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1553 uint32_t &InstanceStart,
1554 uint32_t &InstanceSize);
1555
1556 // Shamelessly stolen from Analysis/CFRefCount.cpp
1557 Selector GetNullarySelector(const char* name) const {
1558 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1559 return CGM.getContext().Selectors.getSelector(0, &II);
1560 }
1561
1562 Selector GetUnarySelector(const char* name) const {
1563 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1564 return CGM.getContext().Selectors.getSelector(1, &II);
1565 }
1566
1567 /// ImplementationIsNonLazy - Check whether the given category or
1568 /// class implementation is "non-lazy".
1569 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1570
1571 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1572 const ObjCIvarDecl *IV) {
1573 // Annotate the load as an invariant load iff inside an instance method
1574 // and ivar belongs to instance method's class and one of its super class.
1575 // This check is needed because the ivar offset is a lazily
1576 // initialised value that may depend on objc_msgSend to perform a fixup on
1577 // the first message dispatch.
1578 //
1579 // An additional opportunity to mark the load as invariant arises when the
1580 // base of the ivar access is a parameter to an Objective C method.
1581 // However, because the parameters are not available in the current
1582 // interface, we cannot perform this check.
1583 //
1584 // Note that for direct methods, because objc_msgSend is skipped,
1585 // and that the method may be inlined, this optimization actually
1586 // can't be performed.
1587 if (const ObjCMethodDecl *MD =
1588 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1589 if (MD->isInstanceMethod() && !MD->isDirectMethod())
1590 if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1591 return IV->getContainingInterface()->isSuperClassOf(ID);
1592 return false;
1593 }
1594
1595 bool isClassLayoutKnownStatically(const ObjCInterfaceDecl *ID) {
1596 // NSObject is a fixed size. If we can see the @implementation of a class
1597 // which inherits from NSObject then we know that all it's offsets also must
1598 // be fixed. FIXME: Can we do this if see a chain of super classes with
1599 // implementations leading to NSObject?
1600 return ID->getImplementation() && ID->getSuperClass() &&
1601 ID->getSuperClass()->getName() == "NSObject";
1602 }
1603
1604public:
1605 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1606
1607 llvm::Constant *getNSConstantStringClassRef() override;
1608
1609 llvm::Function *ModuleInitFunction() override;
1610
1611 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1612 ReturnValueSlot Return,
1613 QualType ResultType, Selector Sel,
1614 llvm::Value *Receiver,
1615 const CallArgList &CallArgs,
1616 const ObjCInterfaceDecl *Class,
1617 const ObjCMethodDecl *Method) override;
1618
1620 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1621 ReturnValueSlot Return, QualType ResultType,
1622 Selector Sel, const ObjCInterfaceDecl *Class,
1623 bool isCategoryImpl, llvm::Value *Receiver,
1624 bool IsClassMessage, const CallArgList &CallArgs,
1625 const ObjCMethodDecl *Method) override;
1626
1627 llvm::Value *GetClass(CodeGenFunction &CGF,
1628 const ObjCInterfaceDecl *ID) override;
1629
1630 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1631 { return EmitSelector(CGF, Sel); }
1632 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1633 { return EmitSelectorAddr(Sel); }
1634
1635 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1636 /// untyped one.
1637 llvm::Value *GetSelector(CodeGenFunction &CGF,
1638 const ObjCMethodDecl *Method) override
1639 { return EmitSelector(CGF, Method->getSelector()); }
1640
1641 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1642
1643 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1644
1645 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1646
1647 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1648 const ObjCProtocolDecl *PD) override;
1649
1650 llvm::Constant *GetEHType(QualType T) override;
1651
1652 llvm::FunctionCallee GetPropertyGetFunction() override {
1653 return ObjCTypes.getGetPropertyFn();
1654 }
1655 llvm::FunctionCallee GetPropertySetFunction() override {
1656 return ObjCTypes.getSetPropertyFn();
1657 }
1658
1659 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
1660 bool copy) override {
1661 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1662 }
1663
1664 llvm::FunctionCallee GetSetStructFunction() override {
1665 return ObjCTypes.getCopyStructFn();
1666 }
1667
1668 llvm::FunctionCallee GetGetStructFunction() override {
1669 return ObjCTypes.getCopyStructFn();
1670 }
1671
1672 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
1673 return ObjCTypes.getCppAtomicObjectFunction();
1674 }
1675
1676 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
1677 return ObjCTypes.getCppAtomicObjectFunction();
1678 }
1679
1680 llvm::FunctionCallee EnumerationMutationFunction() override {
1681 return ObjCTypes.getEnumerationMutationFn();
1682 }
1683
1684 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1685 const ObjCAtTryStmt &S) override;
1686 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1687 const ObjCAtSynchronizedStmt &S) override;
1688 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1689 bool ClearInsertionPoint=true) override;
1690 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1691 Address AddrWeakObj) override;
1692 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1693 llvm::Value *src, Address edst) override;
1694 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1695 llvm::Value *src, Address dest,
1696 bool threadlocal = false) override;
1697 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1698 llvm::Value *src, Address dest,
1699 llvm::Value *ivarOffset) override;
1700 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1701 llvm::Value *src, Address dest) override;
1702 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1703 Address dest, Address src,
1704 llvm::Value *size) override;
1705 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1706 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1707 unsigned CVRQualifiers) override;
1708 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1709 const ObjCInterfaceDecl *Interface,
1710 const ObjCIvarDecl *Ivar) override;
1711};
1712
1713/// A helper class for performing the null-initialization of a return
1714/// value.
1715struct NullReturnState {
1716 llvm::BasicBlock *NullBB;
1717 NullReturnState() : NullBB(nullptr) {}
1718
1719 /// Perform a null-check of the given receiver.
1720 void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1721 // Make blocks for the null-receiver and call edges.
1722 NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1723 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1724
1725 // Check for a null receiver and, if there is one, jump to the
1726 // null-receiver block. There's no point in trying to avoid it:
1727 // we're always going to put *something* there, because otherwise
1728 // we shouldn't have done this null-check in the first place.
1729 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1730 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1731
1732 // Otherwise, start performing the call.
1733 CGF.EmitBlock(callBB);
1734 }
1735
1736 /// Complete the null-return operation. It is valid to call this
1737 /// regardless of whether 'init' has been called.
1738 RValue complete(CodeGenFunction &CGF,
1739 ReturnValueSlot returnSlot,
1740 RValue result,
1741 QualType resultType,
1742 const CallArgList &CallArgs,
1743 const ObjCMethodDecl *Method) {
1744 // If we never had to do a null-check, just use the raw result.
1745 if (!NullBB) return result;
1746
1747 // The continuation block. This will be left null if we don't have an
1748 // IP, which can happen if the method we're calling is marked noreturn.
1749 llvm::BasicBlock *contBB = nullptr;
1750
1751 // Finish the call path.
1752 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1753 if (callBB) {
1754 contBB = CGF.createBasicBlock("msgSend.cont");
1755 CGF.Builder.CreateBr(contBB);
1756 }
1757
1758 // Okay, start emitting the null-receiver block.
1759 CGF.EmitBlock(NullBB);
1760
1761 // Destroy any consumed arguments we've got.
1762 if (Method) {
1764 }
1765
1766 // The phi code below assumes that we haven't needed any control flow yet.
1767 assert(CGF.Builder.GetInsertBlock() == NullBB);
1768
1769 // If we've got a void return, just jump to the continuation block.
1770 if (result.isScalar() && resultType->isVoidType()) {
1771 // No jumps required if the message-send was noreturn.
1772 if (contBB) CGF.EmitBlock(contBB);
1773 return result;
1774 }
1775
1776 // If we've got a scalar return, build a phi.
1777 if (result.isScalar()) {
1778 // Derive the null-initialization value.
1779 llvm::Value *null =
1780 CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(resultType), resultType);
1781
1782 // If no join is necessary, just flow out.
1783 if (!contBB) return RValue::get(null);
1784
1785 // Otherwise, build a phi.
1786 CGF.EmitBlock(contBB);
1787 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1788 phi->addIncoming(result.getScalarVal(), callBB);
1789 phi->addIncoming(null, NullBB);
1790 return RValue::get(phi);
1791 }
1792
1793 // If we've got an aggregate return, null the buffer out.
1794 // FIXME: maybe we should be doing things differently for all the
1795 // cases where the ABI has us returning (1) non-agg values in
1796 // memory or (2) agg values in registers.
1797 if (result.isAggregate()) {
1798 assert(result.isAggregate() && "null init of non-aggregate result?");
1799 if (!returnSlot.isUnused())
1800 CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1801 if (contBB) CGF.EmitBlock(contBB);
1802 return result;
1803 }
1804
1805 // Complex types.
1806 CGF.EmitBlock(contBB);
1807 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1808
1809 // Find the scalar type and its zero value.
1810 llvm::Type *scalarTy = callResult.first->getType();
1811 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1812
1813 // Build phis for both coordinates.
1814 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1815 real->addIncoming(callResult.first, callBB);
1816 real->addIncoming(scalarZero, NullBB);
1817 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1818 imag->addIncoming(callResult.second, callBB);
1819 imag->addIncoming(scalarZero, NullBB);
1820 return RValue::getComplex(real, imag);
1821 }
1822};
1823
1824} // end anonymous namespace
1825
1826/* *** Helper Functions *** */
1827
1828/// getConstantGEP() - Help routine to construct simple GEPs.
1829static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1830 llvm::GlobalVariable *C, unsigned idx0,
1831 unsigned idx1) {
1832 llvm::Value *Idxs[] = {
1833 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1834 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1835 };
1836 return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1837}
1838
1839/// hasObjCExceptionAttribute - Return true if this class or any super
1840/// class has the __objc_exception__ attribute.
1842 const ObjCInterfaceDecl *OID) {
1843 if (OID->hasAttr<ObjCExceptionAttr>())
1844 return true;
1845 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1846 return hasObjCExceptionAttribute(Context, Super);
1847 return false;
1848}
1849
1850static llvm::GlobalValue::LinkageTypes
1852 if (CGM.getTriple().isOSBinFormatMachO() &&
1853 (Section.empty() || Section.startswith("__DATA")))
1854 return llvm::GlobalValue::InternalLinkage;
1855 return llvm::GlobalValue::PrivateLinkage;
1856}
1857
1858/// A helper function to create an internal or private global variable.
1859static llvm::GlobalVariable *
1860finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder,
1861 const llvm::Twine &Name, CodeGenModule &CGM) {
1862 std::string SectionName;
1863 if (CGM.getTriple().isOSBinFormatMachO())
1864 SectionName = "__DATA, __objc_const";
1865 auto *GV = Builder.finishAndCreateGlobal(
1866 Name, CGM.getPointerAlign(), /*constant*/ false,
1867 getLinkageTypeForObjCMetadata(CGM, SectionName));
1868 GV->setSection(SectionName);
1869 return GV;
1870}
1871
1872/* *** CGObjCMac Public Interface *** */
1873
1874CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1875 ObjCTypes(cgm) {
1876 ObjCABI = 1;
1877 EmitImageInfo();
1878}
1879
1880/// GetClass - Return a reference to the class for the given interface
1881/// decl.
1882llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1883 const ObjCInterfaceDecl *ID) {
1884 return EmitClassRef(CGF, ID);
1885}
1886
1887/// GetSelector - Return the pointer to the unique'd string for this selector.
1888llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1889 return EmitSelector(CGF, Sel);
1890}
1891Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1892 return EmitSelectorAddr(Sel);
1893}
1894llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1895 *Method) {
1896 return EmitSelector(CGF, Method->getSelector());
1897}
1898
1899llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1900 if (T->isObjCIdType() ||
1901 T->isObjCQualifiedIdType()) {
1902 return CGM.GetAddrOfRTTIDescriptor(
1903 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1904 }
1905 if (T->isObjCClassType() ||
1907 return CGM.GetAddrOfRTTIDescriptor(
1908 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1909 }
1910 if (T->isObjCObjectPointerType())
1911 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1912
1913 llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1914}
1915
1916/// Generate a constant CFString object.
1917/*
1918 struct __builtin_CFString {
1919 const int *isa; // point to __CFConstantStringClassReference
1920 int flags;
1921 const char *str;
1922 long length;
1923 };
1924*/
1925
1926/// or Generate a constant NSString object.
1927/*
1928 struct __builtin_NSString {
1929 const int *isa; // point to __NSConstantStringClassReference
1930 const char *str;
1931 unsigned int length;
1932 };
1933*/
1934
1936CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1937 return (!CGM.getLangOpts().NoConstantCFStrings
1939 : GenerateConstantNSString(SL));
1940}
1941
1942static llvm::StringMapEntry<llvm::GlobalVariable *> &
1943GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1944 const StringLiteral *Literal, unsigned &StringLength) {
1945 StringRef String = Literal->getString();
1946 StringLength = String.size();
1947 return *Map.insert(std::make_pair(String, nullptr)).first;
1948}
1949
1950llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1951 if (llvm::Value *V = ConstantStringClassRef)
1952 return cast<llvm::Constant>(V);
1953
1954 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1955 std::string str =
1956 StringClass.empty() ? "_NSConstantStringClassReference"
1957 : "_" + StringClass + "ClassReference";
1958
1959 llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1960 auto GV = CGM.CreateRuntimeVariable(PTy, str);
1961 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1962 ConstantStringClassRef = V;
1963 return V;
1964}
1965
1966llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1967 if (llvm::Value *V = ConstantStringClassRef)
1968 return cast<llvm::Constant>(V);
1969
1970 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1971 std::string str =
1972 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1973 : "OBJC_CLASS_$_" + StringClass;
1974 llvm::Constant *GV = GetClassGlobal(str, NotForDefinition);
1975
1976 // Make sure the result is of the correct type.
1977 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1978
1979 ConstantStringClassRef = V;
1980 return V;
1981}
1982
1984CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
1985 unsigned StringLength = 0;
1986 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
1987 GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
1988
1989 if (auto *C = Entry.second)
1990 return ConstantAddress(
1991 C, C->getValueType(), CharUnits::fromQuantity(C->getAlignment()));
1992
1993 // If we don't already have it, get _NSConstantStringClassReference.
1994 llvm::Constant *Class = getNSConstantStringClassRef();
1995
1996 // If we don't already have it, construct the type for a constant NSString.
1997 if (!NSConstantStringType) {
1998 NSConstantStringType =
1999 llvm::StructType::create({
2000 CGM.Int32Ty->getPointerTo(),
2001 CGM.Int8PtrTy,
2002 CGM.IntTy
2003 }, "struct.__builtin_NSString");
2004 }
2005
2006 ConstantInitBuilder Builder(CGM);
2007 auto Fields = Builder.beginStruct(NSConstantStringType);
2008
2009 // Class pointer.
2010 Fields.add(Class);
2011
2012 // String pointer.
2013 llvm::Constant *C =
2014 llvm::ConstantDataArray::getString(VMContext, Entry.first());
2015
2016 llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
2017 bool isConstant = !CGM.getLangOpts().WritableStrings;
2018
2019 auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
2020 Linkage, C, ".str");
2021 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2022 // Don't enforce the target's minimum global alignment, since the only use
2023 // of the string is via this class initializer.
2024 GV->setAlignment(llvm::Align(1));
2025 Fields.addBitCast(GV, CGM.Int8PtrTy);
2026
2027 // String length.
2028 Fields.addInt(CGM.IntTy, StringLength);
2029
2030 // The struct.
2031 CharUnits Alignment = CGM.getPointerAlign();
2032 GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
2033 /*constant*/ true,
2034 llvm::GlobalVariable::PrivateLinkage);
2035 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
2036 const char *NSStringNonFragileABISection =
2037 "__DATA,__objc_stringobj,regular,no_dead_strip";
2038 // FIXME. Fix section.
2039 GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
2040 ? NSStringNonFragileABISection
2041 : NSStringSection);
2042 Entry.second = GV;
2043
2044 return ConstantAddress(GV, GV->getValueType(), Alignment);
2045}
2046
2047enum {
2048 kCFTaggedObjectID_Integer = (1 << 1) + 1
2050
2051/// Generates a message send where the super is the receiver. This is
2052/// a message send to self with special delivery semantics indicating
2053/// which class's method should be called.
2055CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
2056 ReturnValueSlot Return,
2057 QualType ResultType,
2058 Selector Sel,
2059 const ObjCInterfaceDecl *Class,
2060 bool isCategoryImpl,
2061 llvm::Value *Receiver,
2062 bool IsClassMessage,
2063 const CodeGen::CallArgList &CallArgs,
2064 const ObjCMethodDecl *Method) {
2065 // Create and init a super structure; this is a (receiver, class)
2066 // pair we will pass to objc_msgSendSuper.
2067 Address ObjCSuper =
2068 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
2069 "objc_super");
2070 llvm::Value *ReceiverAsObject =
2071 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2072 CGF.Builder.CreateStore(ReceiverAsObject,
2073 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
2074
2075 // If this is a class message the metaclass is passed as the target.
2076 llvm::Type *ClassTyPtr = llvm::PointerType::getUnqual(ObjCTypes.ClassTy);
2077 llvm::Value *Target;
2078 if (IsClassMessage) {
2079 if (isCategoryImpl) {
2080 // Message sent to 'super' in a class method defined in a category
2081 // implementation requires an odd treatment.
2082 // If we are in a class method, we must retrieve the
2083 // _metaclass_ for the current class, pointed at by
2084 // the class's "isa" pointer. The following assumes that
2085 // isa" is the first ivar in a class (which it must be).
2086 Target = EmitClassRef(CGF, Class->getSuperClass());
2087 Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2088 Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, Target,
2089 CGF.getPointerAlign());
2090 } else {
2091 llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2092 llvm::Value *SuperPtr =
2093 CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2094 llvm::Value *Super = CGF.Builder.CreateAlignedLoad(ClassTyPtr, SuperPtr,
2095 CGF.getPointerAlign());
2096 Target = Super;
2097 }
2098 } else if (isCategoryImpl)
2099 Target = EmitClassRef(CGF, Class->getSuperClass());
2100 else {
2101 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2102 ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2103 Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, ClassPtr,
2104 CGF.getPointerAlign());
2105 }
2106 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2107 // ObjCTypes types.
2108 llvm::Type *ClassTy =
2110 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2111 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
2112 return EmitMessageSend(CGF, Return, ResultType, Sel, ObjCSuper.getPointer(),
2113 ObjCTypes.SuperPtrCTy, true, CallArgs, Method, Class,
2114 ObjCTypes);
2115}
2116
2117/// Generate code for a message send expression.
2118CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2119 ReturnValueSlot Return,
2120 QualType ResultType,
2121 Selector Sel,
2122 llvm::Value *Receiver,
2123 const CallArgList &CallArgs,
2124 const ObjCInterfaceDecl *Class,
2125 const ObjCMethodDecl *Method) {
2126 return EmitMessageSend(CGF, Return, ResultType, Sel, Receiver,
2127 CGF.getContext().getObjCIdType(), false, CallArgs,
2128 Method, Class, ObjCTypes);
2129}
2130
2132CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2133 ReturnValueSlot Return,
2134 QualType ResultType,
2135 Selector Sel,
2136 llvm::Value *Arg0,
2137 QualType Arg0Ty,
2138 bool IsSuper,
2139 const CallArgList &CallArgs,
2140 const ObjCMethodDecl *Method,
2141 const ObjCInterfaceDecl *ClassReceiver,
2142 const ObjCCommonTypesHelper &ObjCTypes) {
2143 CodeGenTypes &Types = CGM.getTypes();
2144 auto selTy = CGF.getContext().getObjCSelType();
2145 llvm::Value *SelValue = llvm::UndefValue::get(Types.ConvertType(selTy));
2146
2147 CallArgList ActualArgs;
2148 if (!IsSuper)
2149 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2150 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2151 if (!Method || !Method->isDirectMethod())
2152 ActualArgs.add(RValue::get(SelValue), selTy);
2153 ActualArgs.addFrom(CallArgs);
2154
2155 // If we're calling a method, use the formal signature.
2156 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2157
2158 if (Method)
2159 assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
2160 CGM.getContext().getCanonicalType(ResultType) &&
2161 "Result type mismatch!");
2162
2163 bool ReceiverCanBeNull =
2164 canMessageReceiverBeNull(CGF, Method, IsSuper, ClassReceiver, Arg0);
2165
2166 bool RequiresNullCheck = false;
2167 bool RequiresSelValue = true;
2168
2169 llvm::FunctionCallee Fn = nullptr;
2170 if (Method && Method->isDirectMethod()) {
2171 assert(!IsSuper);
2172 Fn = GenerateDirectMethod(Method, Method->getClassInterface());
2173 // Direct methods will synthesize the proper `_cmd` internally,
2174 // so just don't bother with setting the `_cmd` argument.
2175 RequiresSelValue = false;
2176 } else if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2177 if (ReceiverCanBeNull) RequiresNullCheck = true;
2178 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
2179 : ObjCTypes.getSendStretFn(IsSuper);
2180 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2181 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2182 : ObjCTypes.getSendFpretFn(IsSuper);
2183 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2184 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2185 : ObjCTypes.getSendFp2retFn(IsSuper);
2186 } else {
2187 // arm64 uses objc_msgSend for stret methods and yet null receiver check
2188 // must be made for it.
2189 if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2190 RequiresNullCheck = true;
2191 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2192 : ObjCTypes.getSendFn(IsSuper);
2193 }
2194
2195 // Cast function to proper signature
2196 llvm::Constant *BitcastFn = cast<llvm::Constant>(
2197 CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType));
2198
2199 // We don't need to emit a null check to zero out an indirect result if the
2200 // result is ignored.
2201 if (Return.isUnused())
2202 RequiresNullCheck = false;
2203
2204 // Emit a null-check if there's a consumed argument other than the receiver.
2205 if (!RequiresNullCheck && Method && Method->hasParamDestroyedInCallee())
2206 RequiresNullCheck = true;
2207
2208 NullReturnState nullReturn;
2209 if (RequiresNullCheck) {
2210 nullReturn.init(CGF, Arg0);
2211 }
2212
2213 // If a selector value needs to be passed, emit the load before the call.
2214 if (RequiresSelValue) {
2215 SelValue = GetSelector(CGF, Sel);
2216 ActualArgs[1] = CallArg(RValue::get(SelValue), selTy);
2217 }
2218
2219 llvm::CallBase *CallSite;
2220 CGCallee Callee = CGCallee::forDirect(BitcastFn);
2221 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2222 &CallSite);
2223
2224 // Mark the call as noreturn if the method is marked noreturn and the
2225 // receiver cannot be null.
2226 if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
2227 CallSite->setDoesNotReturn();
2228 }
2229
2230 return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
2231 RequiresNullCheck ? Method : nullptr);
2232}
2233
2235 bool pointee = false) {
2236 // Note that GC qualification applies recursively to C pointer types
2237 // that aren't otherwise decorated. This is weird, but it's probably
2238 // an intentional workaround to the unreliable placement of GC qualifiers.
2239 if (FQT.isObjCGCStrong())
2240 return Qualifiers::Strong;
2241
2242 if (FQT.isObjCGCWeak())
2243 return Qualifiers::Weak;
2244
2245 if (auto ownership = FQT.getObjCLifetime()) {
2246 // Ownership does not apply recursively to C pointer types.
2247 if (pointee) return Qualifiers::GCNone;
2248 switch (ownership) {
2252 case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
2253 case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
2254 }
2255 llvm_unreachable("bad objc ownership");
2256 }
2257
2258 // Treat unqualified retainable pointers as strong.
2259 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2260 return Qualifiers::Strong;
2261
2262 // Walk into C pointer types, but only in GC.
2263 if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2264 if (const PointerType *PT = FQT->getAs<PointerType>())
2265 return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2266 }
2267
2268 return Qualifiers::GCNone;
2269}
2270
2271namespace {
2272 struct IvarInfo {
2274 uint64_t SizeInWords;
2275 IvarInfo(CharUnits offset, uint64_t sizeInWords)
2276 : Offset(offset), SizeInWords(sizeInWords) {}
2277
2278 // Allow sorting based on byte pos.
2279 bool operator<(const IvarInfo &other) const {
2280 return Offset < other.Offset;
2281 }
2282 };
2283
2284 /// A helper class for building GC layout strings.
2285 class IvarLayoutBuilder {
2286 CodeGenModule &CGM;
2287
2288 /// The start of the layout. Offsets will be relative to this value,
2289 /// and entries less than this value will be silently discarded.
2290 CharUnits InstanceBegin;
2291
2292 /// The end of the layout. Offsets will never exceed this value.
2293 CharUnits InstanceEnd;
2294
2295 /// Whether we're generating the strong layout or the weak layout.
2296 bool ForStrongLayout;
2297
2298 /// Whether the offsets in IvarsInfo might be out-of-order.
2299 bool IsDisordered = false;
2300
2302
2303 public:
2304 IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2305 CharUnits instanceEnd, bool forStrongLayout)
2306 : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2307 ForStrongLayout(forStrongLayout) {
2308 }
2309
2310 void visitRecord(const RecordType *RT, CharUnits offset);
2311
2312 template <class Iterator, class GetOffsetFn>
2313 void visitAggregate(Iterator begin, Iterator end,
2314 CharUnits aggrOffset,
2315 const GetOffsetFn &getOffset);
2316
2317 void visitField(const FieldDecl *field, CharUnits offset);
2318
2319 /// Add the layout of a block implementation.
2320 void visitBlock(const CGBlockInfo &blockInfo);
2321
2322 /// Is there any information for an interesting bitmap?
2323 bool hasBitmapData() const { return !IvarsInfo.empty(); }
2324
2325 llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2327
2328 static void dump(ArrayRef<unsigned char> buffer) {
2329 const unsigned char *s = buffer.data();
2330 for (unsigned i = 0, e = buffer.size(); i < e; i++)
2331 if (!(s[i] & 0xf0))
2332 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2333 else
2334 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2335 printf("\n");
2336 }
2337 };
2338} // end anonymous namespace
2339
2340llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2341 const CGBlockInfo &blockInfo) {
2342
2343 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2344 if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2345 return nullPtr;
2346
2347 IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2348 /*for strong layout*/ true);
2349
2350 builder.visitBlock(blockInfo);
2351
2352 if (!builder.hasBitmapData())
2353 return nullPtr;
2354
2356 llvm::Constant *C = builder.buildBitmap(*this, buffer);
2357 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2358 printf("\n block variable layout for block: ");
2359 builder.dump(buffer);
2360 }
2361
2362 return C;
2363}
2364
2365void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2366 // __isa is the first field in block descriptor and must assume by runtime's
2367 // convention that it is GC'able.
2368 IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2369
2370 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2371
2372 // Ignore the optional 'this' capture: C++ objects are not assumed
2373 // to be GC'ed.
2374
2375 CharUnits lastFieldOffset;
2376
2377 // Walk the captured variables.
2378 for (const auto &CI : blockDecl->captures()) {
2379 const VarDecl *variable = CI.getVariable();
2380 QualType type = variable->getType();
2381
2382 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2383
2384 // Ignore constant captures.
2385 if (capture.isConstant()) continue;
2386
2387 CharUnits fieldOffset = capture.getOffset();
2388
2389 // Block fields are not necessarily ordered; if we detect that we're
2390 // adding them out-of-order, make sure we sort later.
2391 if (fieldOffset < lastFieldOffset)
2392 IsDisordered = true;
2393 lastFieldOffset = fieldOffset;
2394
2395 // __block variables are passed by their descriptor address.
2396 if (CI.isByRef()) {
2397 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2398 continue;
2399 }
2400
2401 assert(!type->isArrayType() && "array variable should not be caught");
2402 if (const RecordType *record = type->getAs<RecordType>()) {
2403 visitRecord(record, fieldOffset);
2404 continue;
2405 }
2406
2408
2409 if (GCAttr == Qualifiers::Strong) {
2410 assert(CGM.getContext().getTypeSize(type) ==
2411 CGM.getTarget().getPointerWidth(LangAS::Default));
2412 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2413 }
2414 }
2415}
2416
2417/// getBlockCaptureLifetime - This routine returns life time of the captured
2418/// block variable for the purpose of block layout meta-data generation. FQT is
2419/// the type of the variable captured in the block.
2420Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2421 bool ByrefLayout) {
2422 // If it has an ownership qualifier, we're done.
2423 if (auto lifetime = FQT.getObjCLifetime())
2424 return lifetime;
2425
2426 // If it doesn't, and this is ARC, it has no ownership.
2427 if (CGM.getLangOpts().ObjCAutoRefCount)
2428 return Qualifiers::OCL_None;
2429
2430 // In MRC, retainable pointers are owned by non-__block variables.
2431 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2433
2434 return Qualifiers::OCL_None;
2435}
2436
2437void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2438 Qualifiers::ObjCLifetime LifeTime,
2439 CharUnits FieldOffset,
2440 CharUnits FieldSize) {
2441 // __block variables are passed by their descriptor address.
2442 if (IsByref)
2443 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2444 FieldSize));
2445 else if (LifeTime == Qualifiers::OCL_Strong)
2446 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2447 FieldSize));
2448 else if (LifeTime == Qualifiers::OCL_Weak)
2449 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2450 FieldSize));
2451 else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2452 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2453 FieldSize));
2454 else
2455 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2456 FieldOffset,
2457 FieldSize));
2458}
2459
2460void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2461 const RecordDecl *RD,
2463 CharUnits BytePos, bool &HasUnion,
2464 bool ByrefLayout) {
2465 bool IsUnion = (RD && RD->isUnion());
2466 CharUnits MaxUnionSize = CharUnits::Zero();
2467 const FieldDecl *MaxField = nullptr;
2468 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2469 CharUnits MaxFieldOffset = CharUnits::Zero();
2470 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2471
2472 if (RecFields.empty())
2473 return;
2474 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2475
2476 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2477 const FieldDecl *Field = RecFields[i];
2478 // Note that 'i' here is actually the field index inside RD of Field,
2479 // although this dependency is hidden.
2480 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2481 CharUnits FieldOffset =
2483
2484 // Skip over unnamed or bitfields
2485 if (!Field->getIdentifier() || Field->isBitField()) {
2486 LastFieldBitfieldOrUnnamed = Field;
2487 LastBitfieldOrUnnamedOffset = FieldOffset;
2488 continue;
2489 }
2490
2491 LastFieldBitfieldOrUnnamed = nullptr;
2492 QualType FQT = Field->getType();
2493 if (FQT->isRecordType() || FQT->isUnionType()) {
2494 if (FQT->isUnionType())
2495 HasUnion = true;
2496
2497 BuildRCBlockVarRecordLayout(FQT->castAs<RecordType>(),
2498 BytePos + FieldOffset, HasUnion);
2499 continue;
2500 }
2501
2502 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2503 auto *CArray = cast<ConstantArrayType>(Array);
2504 uint64_t ElCount = CArray->getSize().getZExtValue();
2505 assert(CArray && "only array with known element size is supported");
2506 FQT = CArray->getElementType();
2507 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2508 auto *CArray = cast<ConstantArrayType>(Array);
2509 ElCount *= CArray->getSize().getZExtValue();
2510 FQT = CArray->getElementType();
2511 }
2512 if (FQT->isRecordType() && ElCount) {
2513 int OldIndex = RunSkipBlockVars.size() - 1;
2514 auto *RT = FQT->castAs<RecordType>();
2515 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset, HasUnion);
2516
2517 // Replicate layout information for each array element. Note that
2518 // one element is already done.
2519 uint64_t ElIx = 1;
2520 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2522 for (int i = OldIndex+1; i <= FirstIndex; ++i)
2523 RunSkipBlockVars.push_back(
2524 RUN_SKIP(RunSkipBlockVars[i].opcode,
2525 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2526 RunSkipBlockVars[i].block_var_size));
2527 }
2528 continue;
2529 }
2530 }
2531 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2532 if (IsUnion) {
2533 CharUnits UnionIvarSize = FieldSize;
2534 if (UnionIvarSize > MaxUnionSize) {
2535 MaxUnionSize = UnionIvarSize;
2536 MaxField = Field;
2537 MaxFieldOffset = FieldOffset;
2538 }
2539 } else {
2540 UpdateRunSkipBlockVars(false,
2541 getBlockCaptureLifetime(FQT, ByrefLayout),
2542 BytePos + FieldOffset,
2543 FieldSize);
2544 }
2545 }
2546
2547 if (LastFieldBitfieldOrUnnamed) {
2548 if (LastFieldBitfieldOrUnnamed->isBitField()) {
2549 // Last field was a bitfield. Must update the info.
2550 uint64_t BitFieldSize
2551 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2552 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2553 ((BitFieldSize % ByteSizeInBits) != 0);
2555 Size += LastBitfieldOrUnnamedOffset;
2556 UpdateRunSkipBlockVars(false,
2557 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2558 ByrefLayout),
2559 BytePos + LastBitfieldOrUnnamedOffset,
2560 Size);
2561 } else {
2562 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2563 // Last field was unnamed. Must update skip info.
2564 CharUnits FieldSize
2565 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2566 UpdateRunSkipBlockVars(false,
2567 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2568 ByrefLayout),
2569 BytePos + LastBitfieldOrUnnamedOffset,
2570 FieldSize);
2571 }
2572 }
2573
2574 if (MaxField)
2575 UpdateRunSkipBlockVars(false,
2576 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2577 BytePos + MaxFieldOffset,
2578 MaxUnionSize);
2579}
2580
2581void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2582 CharUnits BytePos,
2583 bool &HasUnion,
2584 bool ByrefLayout) {
2585 const RecordDecl *RD = RT->getDecl();
2587 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2588 const llvm::StructLayout *RecLayout =
2589 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2590
2591 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2592}
2593
2594/// InlineLayoutInstruction - This routine produce an inline instruction for the
2595/// block variable layout if it can. If not, it returns 0. Rules are as follow:
2596/// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2597/// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2598/// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2599/// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2600/// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2601/// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2602/// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2603uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2605 uint64_t Result = 0;
2606 if (Layout.size() <= 3) {
2607 unsigned size = Layout.size();
2608 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2609 unsigned char inst;
2610 enum BLOCK_LAYOUT_OPCODE opcode ;
2611 switch (size) {
2612 case 3:
2613 inst = Layout[0];
2614 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2615 if (opcode == BLOCK_LAYOUT_STRONG)
2616 strong_word_count = (inst & 0xF)+1;
2617 else
2618 return 0;
2619 inst = Layout[1];
2620 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2621 if (opcode == BLOCK_LAYOUT_BYREF)
2622 byref_word_count = (inst & 0xF)+1;
2623 else
2624 return 0;
2625 inst = Layout[2];
2626 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2627 if (opcode == BLOCK_LAYOUT_WEAK)
2628 weak_word_count = (inst & 0xF)+1;
2629 else
2630 return 0;
2631 break;
2632
2633 case 2:
2634 inst = Layout[0];
2635 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2636 if (opcode == BLOCK_LAYOUT_STRONG) {
2637 strong_word_count = (inst & 0xF)+1;
2638 inst = Layout[1];
2639 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2640 if (opcode == BLOCK_LAYOUT_BYREF)
2641 byref_word_count = (inst & 0xF)+1;
2642 else if (opcode == BLOCK_LAYOUT_WEAK)
2643 weak_word_count = (inst & 0xF)+1;
2644 else
2645 return 0;
2646 }
2647 else if (opcode == BLOCK_LAYOUT_BYREF) {
2648 byref_word_count = (inst & 0xF)+1;
2649 inst = Layout[1];
2650 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2651 if (opcode == BLOCK_LAYOUT_WEAK)
2652 weak_word_count = (inst & 0xF)+1;
2653 else
2654 return 0;
2655 }
2656 else
2657 return 0;
2658 break;
2659
2660 case 1:
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 if (opcode == BLOCK_LAYOUT_BYREF)
2666 byref_word_count = (inst & 0xF)+1;
2667 else if (opcode == BLOCK_LAYOUT_WEAK)
2668 weak_word_count = (inst & 0xF)+1;
2669 else
2670 return 0;
2671 break;
2672
2673 default:
2674 return 0;
2675 }
2676
2677 // Cannot inline when any of the word counts is 15. Because this is one less
2678 // than the actual work count (so 15 means 16 actual word counts),
2679 // and we can only display 0 thru 15 word counts.
2680 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2681 return 0;
2682
2683 unsigned count =
2684 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2685
2686 if (size == count) {
2687 if (strong_word_count)
2688 Result = strong_word_count;
2689 Result <<= 4;
2690 if (byref_word_count)
2691 Result += byref_word_count;
2692 Result <<= 4;
2693 if (weak_word_count)
2694 Result += weak_word_count;
2695 }
2696 }
2697 return Result;
2698}
2699
2700llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2701 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2702 if (RunSkipBlockVars.empty())
2703 return nullPtr;
2704 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(LangAS::Default);
2705 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2706 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2707
2708 // Sort on byte position; captures might not be allocated in order,
2709 // and unions can do funny things.
2710 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2712
2713 unsigned size = RunSkipBlockVars.size();
2714 for (unsigned i = 0; i < size; i++) {
2715 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2716 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2717 CharUnits end_byte_pos = start_byte_pos;
2718 unsigned j = i+1;
2719 while (j < size) {
2720 if (opcode == RunSkipBlockVars[j].opcode) {
2721 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2722 i++;
2723 }
2724 else
2725 break;
2726 }
2727 CharUnits size_in_bytes =
2728 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2729 if (j < size) {
2730 CharUnits gap =
2731 RunSkipBlockVars[j].block_var_bytepos -
2732 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2733 size_in_bytes += gap;
2734 }
2735 CharUnits residue_in_bytes = CharUnits::Zero();
2736 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2737 residue_in_bytes = size_in_bytes % WordSizeInBytes;
2738 size_in_bytes -= residue_in_bytes;
2739 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2740 }
2741
2742 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2743 while (size_in_words >= 16) {
2744 // Note that value in imm. is one less that the actual
2745 // value. So, 0xf means 16 words follow!
2746 unsigned char inst = (opcode << 4) | 0xf;
2747 Layout.push_back(inst);
2748 size_in_words -= 16;
2749 }
2750 if (size_in_words > 0) {
2751 // Note that value in imm. is one less that the actual
2752 // value. So, we subtract 1 away!
2753 unsigned char inst = (opcode << 4) | (size_in_words-1);
2754 Layout.push_back(inst);
2755 }
2756 if (residue_in_bytes > CharUnits::Zero()) {
2757 unsigned char inst =
2758 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2759 Layout.push_back(inst);
2760 }
2761 }
2762
2763 while (!Layout.empty()) {
2764 unsigned char inst = Layout.back();
2765 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2766 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2767 Layout.pop_back();
2768 else
2769 break;
2770 }
2771
2772 uint64_t Result = InlineLayoutInstruction(Layout);
2773 if (Result != 0) {
2774 // Block variable layout instruction has been inlined.
2775 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2776 if (ComputeByrefLayout)
2777 printf("\n Inline BYREF variable layout: ");
2778 else
2779 printf("\n Inline block variable layout: ");
2780 printf("0x0%" PRIx64 "", Result);
2781 if (auto numStrong = (Result & 0xF00) >> 8)
2782 printf(", BL_STRONG:%d", (int) numStrong);
2783 if (auto numByref = (Result & 0x0F0) >> 4)
2784 printf(", BL_BYREF:%d", (int) numByref);
2785 if (auto numWeak = (Result & 0x00F) >> 0)
2786 printf(", BL_WEAK:%d", (int) numWeak);
2787 printf(", BL_OPERATOR:0\n");
2788 }
2789 return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2790 }
2791
2792 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2793 Layout.push_back(inst);
2794 std::string BitMap;
2795 for (unsigned i = 0, e = Layout.size(); i != e; i++)
2796 BitMap += Layout[i];
2797
2798 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2799 if (ComputeByrefLayout)
2800 printf("\n Byref variable layout: ");
2801 else
2802 printf("\n Block variable layout: ");
2803 for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2804 unsigned char inst = BitMap[i];
2805 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2806 unsigned delta = 1;
2807 switch (opcode) {
2808 case BLOCK_LAYOUT_OPERATOR:
2809 printf("BL_OPERATOR:");
2810 delta = 0;
2811 break;
2812 case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2813 printf("BL_NON_OBJECT_BYTES:");
2814 break;
2815 case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2816 printf("BL_NON_OBJECT_WORD:");
2817 break;
2818 case BLOCK_LAYOUT_STRONG:
2819 printf("BL_STRONG:");
2820 break;
2821 case BLOCK_LAYOUT_BYREF:
2822 printf("BL_BYREF:");
2823 break;
2824 case BLOCK_LAYOUT_WEAK:
2825 printf("BL_WEAK:");
2826 break;
2827 case BLOCK_LAYOUT_UNRETAINED:
2828 printf("BL_UNRETAINED:");
2829 break;
2830 }
2831 // Actual value of word count is one more that what is in the imm.
2832 // field of the instruction
2833 printf("%d", (inst & 0xf) + delta);
2834 if (i < e-1)
2835 printf(", ");
2836 else
2837 printf("\n");
2838 }
2839 }
2840
2841 auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2842 /*ForceNonFragileABI=*/true,
2843 /*NullTerminate=*/false);
2844 return getConstantGEP(VMContext, Entry, 0, 0);
2845}
2846
2847static std::string getBlockLayoutInfoString(
2848 const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
2849 bool HasCopyDisposeHelpers) {
2850 std::string Str;
2851 for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
2852 if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
2853 // Copy/dispose helpers don't have any information about
2854 // __unsafe_unretained captures, so unconditionally concatenate a string.
2855 Str += "u";
2856 } else if (HasCopyDisposeHelpers) {
2857 // Information about __strong, __weak, or byref captures has already been
2858 // encoded into the names of the copy/dispose helpers. We have to add a
2859 // string here only when the copy/dispose helpers aren't generated (which
2860 // happens when the block is non-escaping).
2861 continue;
2862 } else {
2863 switch (R.opcode) {
2864 case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
2865 Str += "s";
2866 break;
2867 case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
2868 Str += "r";
2869 break;
2870 case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
2871 Str += "w";
2872 break;
2873 default:
2874 continue;
2875 }
2876 }
2877 Str += llvm::to_string(R.block_var_bytepos.getQuantity());
2878 Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
2879 }
2880 return Str;
2881}
2882
2883void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
2884 const CGBlockInfo &blockInfo) {
2885 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2886
2887 RunSkipBlockVars.clear();
2888 bool hasUnion = false;
2889
2890 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(LangAS::Default);
2891 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2892 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2893
2894 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2895
2896 // Calculate the basic layout of the block structure.
2897 const llvm::StructLayout *layout =
2898 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2899
2900 // Ignore the optional 'this' capture: C++ objects are not assumed
2901 // to be GC'ed.
2902 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2903 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2905 blockInfo.BlockHeaderForcedGapSize);
2906 // Walk the captured variables.
2907 for (const auto &CI : blockDecl->captures()) {
2908 const VarDecl *variable = CI.getVariable();
2909 QualType type = variable->getType();
2910
2911 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2912
2913 // Ignore constant captures.
2914 if (capture.isConstant()) continue;
2915
2916 CharUnits fieldOffset =
2917 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2918
2919 assert(!type->isArrayType() && "array variable should not be caught");
2920 if (!CI.isByRef())
2921 if (const RecordType *record = type->getAs<RecordType>()) {
2922 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2923 continue;
2924 }
2925 CharUnits fieldSize;
2926 if (CI.isByRef())
2927 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2928 else
2929 fieldSize = CGM.getContext().getTypeSizeInChars(type);
2930 UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2931 fieldOffset, fieldSize);
2932 }
2933}
2934
2935llvm::Constant *
2936CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2937 const CGBlockInfo &blockInfo) {
2938 fillRunSkipBlockVars(CGM, blockInfo);
2939 return getBitmapBlockLayout(false);
2940}
2941
2942std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
2943 const CGBlockInfo &blockInfo) {
2944 fillRunSkipBlockVars(CGM, blockInfo);
2945 return getBlockLayoutInfoString(RunSkipBlockVars, blockInfo.NeedsCopyDispose);
2946}
2947
2948llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2949 QualType T) {
2950 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2951 assert(!T->isArrayType() && "__block array variable should not be caught");
2952 CharUnits fieldOffset;
2953 RunSkipBlockVars.clear();
2954 bool hasUnion = false;
2955 if (const RecordType *record = T->getAs<RecordType>()) {
2956 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2957 llvm::Constant *Result = getBitmapBlockLayout(true);
2958 if (isa<llvm::ConstantInt>(Result))
2959 Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
2960 return Result;
2961 }
2962 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2963 return nullPtr;
2964}
2965
2966llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2967 const ObjCProtocolDecl *PD) {
2968 // FIXME: I don't understand why gcc generates this, or where it is
2969 // resolved. Investigate. Its also wasteful to look this up over and over.
2970 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2971
2972 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2973 ObjCTypes.getExternalProtocolPtrTy());
2974}
2975
2976void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2977 // FIXME: We shouldn't need this, the protocol decl should contain enough
2978 // information to tell us whether this was a declaration or a definition.
2979 DefinedProtocols.insert(PD->getIdentifier());
2980
2981 // If we have generated a forward reference to this protocol, emit
2982 // it now. Otherwise do nothing, the protocol objects are lazily
2983 // emitted.
2984 if (Protocols.count(PD->getIdentifier()))
2985 GetOrEmitProtocol(PD);
2986}
2987
2988llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
2989 if (DefinedProtocols.count(PD->getIdentifier()))
2990 return GetOrEmitProtocol(PD);
2991
2992 return GetOrEmitProtocolRef(PD);
2993}
2994
2995llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
2996 CodeGenFunction &CGF,
2997 const ObjCInterfaceDecl *ID,
2998 ObjCCommonTypesHelper &ObjCTypes) {
2999 llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn();
3000
3001 llvm::Value *className = CGF.CGM
3002 .GetAddrOfConstantCString(std::string(
3003 ID->getObjCRuntimeNameAsString()))
3004 .getPointer();
3005 ASTContext &ctx = CGF.CGM.getContext();
3006 className =
3007 CGF.Builder.CreateBitCast(className,
3008 CGF.ConvertType(
3009 ctx.getPointerType(ctx.CharTy.withConst())));
3010 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
3011 call->setDoesNotThrow();
3012 return call;
3013}
3014
3015/*
3016// Objective-C 1.0 extensions
3017struct _objc_protocol {
3018struct _objc_protocol_extension *isa;
3019char *protocol_name;
3020struct _objc_protocol_list *protocol_list;
3021struct _objc__method_prototype_list *instance_methods;
3022struct _objc__method_prototype_list *class_methods
3023};
3024
3025See EmitProtocolExtension().
3026*/
3027llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
3028 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
3029
3030 // Early exit if a defining object has already been generated.
3031 if (Entry && Entry->hasInitializer())
3032 return Entry;
3033
3034 // Use the protocol definition, if there is one.
3035 if (const ObjCProtocolDecl *Def = PD->getDefinition())
3036 PD = Def;
3037
3038 // FIXME: I don't understand why gcc generates this, or where it is
3039 // resolved. Investigate. Its also wasteful to look this up over and over.
3040 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3041
3042 // Construct method lists.
3043 auto methodLists = ProtocolMethodLists::get(PD);
3044
3045 ConstantInitBuilder builder(CGM);
3046 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3047 values.add(EmitProtocolExtension(PD, methodLists));
3048 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3049 values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3050 PD->protocol_begin(), PD->protocol_end()));
3051 values.add(methodLists.emitMethodList(this, PD,
3052 ProtocolMethodLists::RequiredInstanceMethods));
3053 values.add(methodLists.emitMethodList(this, PD,
3054 ProtocolMethodLists::RequiredClassMethods));
3055
3056 if (Entry) {
3057 // Already created, update the initializer.
3058 assert(Entry->hasPrivateLinkage());
3059 values.finishAndSetAsInitializer(Entry);
3060 } else {
3061 Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3062 CGM.getPointerAlign(),
3063 /*constant*/ false,
3064 llvm::GlobalValue::PrivateLinkage);
3065 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3066
3067 Protocols[PD->getIdentifier()] = Entry;
3068 }
3069 CGM.addCompilerUsedGlobal(Entry);
3070
3071 return Entry;
3072}
3073
3074llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3075 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3076
3077 if (!Entry) {
3078 // We use the initializer as a marker of whether this is a forward
3079 // reference or not. At module finalization we add the empty
3080 // contents for protocols which were referenced but never defined.
3081 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3082 false, llvm::GlobalValue::PrivateLinkage,
3083 nullptr, "OBJC_PROTOCOL_" + PD->getName());
3084 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3085 // FIXME: Is this necessary? Why only for protocol?
3086 Entry->setAlignment(llvm::Align(4));
3087 }
3088
3089 return Entry;
3090}
3091
3092/*
3093 struct _objc_protocol_extension {
3094 uint32_t size;
3095 struct objc_method_description_list *optional_instance_methods;
3096 struct objc_method_description_list *optional_class_methods;
3097 struct objc_property_list *instance_properties;
3098 const char ** extendedMethodTypes;
3099 struct objc_property_list *class_properties;
3100 };
3101*/
3102llvm::Constant *
3103CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3104 const ProtocolMethodLists &methodLists) {
3105 auto optInstanceMethods =
3106 methodLists.emitMethodList(this, PD,
3107 ProtocolMethodLists::OptionalInstanceMethods);
3108 auto optClassMethods =
3109 methodLists.emitMethodList(this, PD,
3110 ProtocolMethodLists::OptionalClassMethods);
3111
3112 auto extendedMethodTypes =
3113 EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3114 methodLists.emitExtendedTypesArray(this),
3115 ObjCTypes);
3116
3117 auto instanceProperties =
3118 EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3119 ObjCTypes, false);
3120 auto classProperties =
3121 EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3122 PD, ObjCTypes, true);
3123
3124 // Return null if no extension bits are used.
3125 if (optInstanceMethods->isNullValue() &&
3126 optClassMethods->isNullValue() &&
3127 extendedMethodTypes->isNullValue() &&
3128 instanceProperties->isNullValue() &&
3129 classProperties->isNullValue()) {
3130 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3131 }
3132
3133 uint64_t size =
3134 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3135
3136 ConstantInitBuilder builder(CGM);
3137 auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3138 values.addInt(ObjCTypes.IntTy, size);
3139 values.add(optInstanceMethods);
3140 values.add(optClassMethods);
3141 values.add(instanceProperties);
3142 values.add(extendedMethodTypes);
3143 values.add(classProperties);
3144
3145 // No special section, but goes in llvm.used
3146 return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3147 StringRef(), CGM.getPointerAlign(), true);
3148}
3149
3150/*
3151 struct objc_protocol_list {
3152 struct objc_protocol_list *next;
3153 long count;
3154 Protocol *list[];
3155 };
3156*/
3157llvm::Constant *
3158CGObjCMac::EmitProtocolList(Twine name,
3161 // Just return null for empty protocol lists
3162 auto PDs = GetRuntimeProtocolList(begin, end);
3163 if (PDs.empty())
3164 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3165
3166 ConstantInitBuilder builder(CGM);
3167 auto values = builder.beginStruct();
3168
3169 // This field is only used by the runtime.
3170 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3171
3172 // Reserve a slot for the count.
3173 auto countSlot = values.addPlaceholder();
3174
3175 auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3176 for (const auto *Proto : PDs)
3177 refsArray.add(GetProtocolRef(Proto));
3178
3179 auto count = refsArray.size();
3180
3181 // This list is null terminated.
3182 refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3183
3184 refsArray.finishAndAddTo(values);
3185 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3186
3187 StringRef section;
3188 if (CGM.getTriple().isOSBinFormatMachO())
3189 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3190
3191 llvm::GlobalVariable *GV =
3192 CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3193 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3194}
3195
3196static void
3199 const ObjCProtocolDecl *Proto,
3200 bool IsClassProperty) {
3201 for (const auto *PD : Proto->properties()) {
3202 if (IsClassProperty != PD->isClassProperty())
3203 continue;
3204 if (!PropertySet.insert(PD->getIdentifier()).second)
3205 continue;
3206 Properties.push_back(PD);
3207 }
3208
3209 for (const auto *P : Proto->protocols())
3210 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3211}
3212
3213/*
3214 struct _objc_property {
3215 const char * const name;
3216 const char * const attributes;
3217 };
3218
3219 struct _objc_property_list {
3220 uint32_t entsize; // sizeof (struct _objc_property)
3221 uint32_t prop_count;
3222 struct _objc_property[prop_count];
3223 };
3224*/
3225llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3226 const Decl *Container,
3227 const ObjCContainerDecl *OCD,
3228 const ObjCCommonTypesHelper &ObjCTypes,
3229 bool IsClassProperty) {
3230 if (IsClassProperty) {
3231 // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3232 // with deployment target < 9.0.
3233 const llvm::Triple &Triple = CGM.getTarget().getTriple();
3234 if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3235 (Triple.isiOS() && Triple.isOSVersionLT(9)))
3236 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3237 }
3238
3241
3242 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3243 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3244 for (auto *PD : ClassExt->properties()) {
3245 if (IsClassProperty != PD->isClassProperty())
3246 continue;
3247 if (PD->isDirectProperty())
3248 continue;
3249 PropertySet.insert(PD->getIdentifier());
3250 Properties.push_back(PD);
3251 }
3252
3253 for (const auto *PD : OCD->properties()) {
3254 if (IsClassProperty != PD->isClassProperty())
3255 continue;
3256 // Don't emit duplicate metadata for properties that were already in a
3257 // class extension.
3258 if (!PropertySet.insert(PD->getIdentifier()).second)
3259 continue;
3260 if (PD->isDirectProperty())
3261 continue;
3262 Properties.push_back(PD);
3263 }
3264
3265 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3266 for (const auto *P : OID->all_referenced_protocols())
3267 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3268 }
3269 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3270 for (const auto *P : CD->protocols())
3271 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3272 }
3273
3274 // Return null for empty list.
3275 if (Properties.empty())
3276 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3277
3278 unsigned propertySize =
3279 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3280
3281 ConstantInitBuilder builder(CGM);
3282 auto values = builder.beginStruct();
3283 values.addInt(ObjCTypes.IntTy, propertySize);
3284 values.addInt(ObjCTypes.IntTy, Properties.size());
3285 auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3286 for (auto PD : Properties) {
3287 auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3288 property.add(GetPropertyName(PD->getIdentifier()));
3289 property.add(GetPropertyTypeString(PD, Container));
3290 property.finishAndAddTo(propertiesArray);
3291 }
3292 propertiesArray.finishAndAddTo(values);
3293
3294 StringRef Section;
3295 if (CGM.getTriple().isOSBinFormatMachO())
3296 Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3297 : "__OBJC,__property,regular,no_dead_strip";
3298
3299 llvm::GlobalVariable *GV =
3300 CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3301 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3302}
3303
3304llvm::Constant *
3305CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3306 ArrayRef<llvm::Constant*> MethodTypes,
3307 const ObjCCommonTypesHelper &ObjCTypes) {
3308 // Return null for empty list.
3309 if (MethodTypes.empty())
3310 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3311
3312 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3313 MethodTypes.size());
3314 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3315
3316 StringRef Section;
3317 if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3318 Section = "__DATA, __objc_const";
3319
3320 llvm::GlobalVariable *GV =
3321 CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3322 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3323}
3324
3325/*
3326 struct _objc_category {
3327 char *category_name;
3328 char *class_name;
3329 struct _objc_method_list *instance_methods;
3330 struct _objc_method_list *class_methods;
3331 struct _objc_protocol_list *protocols;
3332 uint32_t size; // <rdar://4585769>
3333 struct _objc_property_list *instance_properties;
3334 struct _objc_property_list *class_properties;
3335 };
3336*/
3337void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3338 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3339
3340 // FIXME: This is poor design, the OCD should have a pointer to the category
3341 // decl. Additionally, note that Category can be null for the @implementation
3342 // w/o an @interface case. Sema should just create one for us as it does for
3343 // @implementation so everyone else can live life under a clear blue sky.
3344 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3345 const ObjCCategoryDecl *Category =
3346 Interface->FindCategoryDeclaration(OCD->getIdentifier());
3347
3348 SmallString<256> ExtName;
3349 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3350 << OCD->getName();
3351
3352 ConstantInitBuilder Builder(CGM);
3353 auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3354
3355 enum {
3356 InstanceMethods,
3357 ClassMethods,
3358 NumMethodLists
3359 };
3360 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3361 for (const auto *MD : OCD->methods()) {
3362 if (!MD->isDirectMethod())
3363 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3364 }
3365
3366 Values.add(GetClassName(OCD->getName()));
3367 Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3368 LazySymbols.insert(Interface->getIdentifier());
3369
3370 Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3371 Methods[InstanceMethods]));
3372 Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3373 Methods[ClassMethods]));
3374 if (Category) {
3375 Values.add(
3376 EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3377 Category->protocol_begin(), Category->protocol_end()));
3378 } else {
3379 Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3380 }
3381 Values.addInt(ObjCTypes.IntTy, Size);
3382
3383 // If there is no category @interface then there can be no properties.
3384 if (Category) {
3385 Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
3386 OCD, Category, ObjCTypes, false));
3387 Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3388 OCD, Category, ObjCTypes, true));
3389 } else {
3390 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3391 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3392 }
3393
3394 llvm::GlobalVariable *GV =
3395 CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3396 "__OBJC,__category,regular,no_dead_strip",
3397 CGM.getPointerAlign(), true);
3398 DefinedCategories.push_back(GV);
3399 DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3400 // method definition entries must be clear for next implementation.
3401 MethodDefinitions.clear();
3402}
3403
3405 /// Apparently: is not a meta-class.
3407
3408 /// Is a meta-class.
3410
3411 /// Has a non-trivial constructor or destructor.
3413
3414 /// Has hidden visibility.
3416
3417 /// Class implementation was compiled under ARC.
3419
3420 /// Class implementation was compiled under MRC and has MRC weak ivars.
3421 /// Exclusive with CompiledByARC.
3423};
3424
3426 /// Is a meta-class.
3428
3429 /// Is a root class.
3431
3432 /// Has a non-trivial constructor or destructor.
3434
3435 /// Has hidden visibility.
3437
3438 /// Has the exception attribute.
3440
3441 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3443
3444 /// Class implementation was compiled under ARC.
3446
3447 /// Class has non-trivial destructors, but zero-initialization is okay.
3449
3450 /// Class implementation was compiled under MRC and has MRC weak ivars.
3451 /// Exclusive with CompiledByARC.
3453};
3454
3456 if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3457 return true;
3458 }
3459
3460 if (auto recType = type->getAs<RecordType>()) {
3461 for (auto *field : recType->getDecl()->fields()) {
3462 if (hasWeakMember(field->getType()))
3463 return true;
3464 }
3465 }
3466
3467 return false;
3468}
3469
3470/// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3471/// (and actually fill in a layout string) if we really do have any
3472/// __weak ivars.
3474 const ObjCImplementationDecl *ID) {
3475 if (!CGM.getLangOpts().ObjCWeak) return false;
3476 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3477
3478 for (const ObjCIvarDecl *ivar =
3479 ID->getClassInterface()->all_declared_ivar_begin();
3480 ivar; ivar = ivar->getNextIvar()) {
3481 if (hasWeakMember(ivar->getType()))
3482 return true;
3483 }
3484
3485 return false;
3486}
3487
3488/*
3489 struct _objc_class {
3490 Class isa;
3491 Class super_class;
3492 const char *name;
3493 long version;
3494 long info;
3495 long instance_size;
3496 struct _objc_ivar_list *ivars;
3497 struct _objc_method_list *methods;
3498 struct _objc_cache *cache;
3499 struct _objc_protocol_list *protocols;
3500 // Objective-C 1.0 extensions (<rdr://4585769>)
3501 const char *ivar_layout;
3502 struct _objc_class_ext *ext;
3503 };
3504
3505 See EmitClassExtension();
3506*/
3507void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3508 IdentifierInfo *RuntimeName =
3509 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3510 DefinedSymbols.insert(RuntimeName);
3511
3512 std::string ClassName = ID->getNameAsString();
3513 // FIXME: Gross
3514 ObjCInterfaceDecl *Interface =
3515 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3516 llvm::Constant *Protocols =
3517 EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3518 Interface->all_referenced_protocol_begin(),
3519 Interface->all_referenced_protocol_end());
3520 unsigned Flags = FragileABI_Class_Factory;
3521 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3523
3524 bool hasMRCWeak = false;
3525
3526 if (CGM.getLangOpts().ObjCAutoRefCount)
3528 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3530
3531 CharUnits Size =
3533
3534 // FIXME: Set CXX-structors flag.
3535 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3536 Flags |= FragileABI_Class_Hidden;
3537
3538 enum {
3539 InstanceMethods,
3540 ClassMethods,
3541 NumMethodLists
3542 };
3543 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3544 for (const auto *MD : ID->methods()) {
3545 if (!MD->isDirectMethod())
3546 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3547 }
3548
3549 for (const auto *PID : ID->property_impls()) {
3550 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3551 if (PID->getPropertyDecl()->isDirectProperty())
3552 continue;
3553 if (ObjCMethodDecl *MD = PID->getGetterMethodDecl())
3554 if (GetMethodDefinition(MD))
3555 Methods[InstanceMethods].push_back(MD);
3556 if (ObjCMethodDecl *MD = PID->getSetterMethodDecl())
3557 if (GetMethodDefinition(MD))
3558 Methods[InstanceMethods].push_back(MD);
3559 }
3560 }
3561
3562 ConstantInitBuilder builder(CGM);
3563 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3564 values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3565 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3566 // Record a reference to the super class.
3567 LazySymbols.insert(Super->getIdentifier());
3568
3569 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3570 ObjCTypes.ClassPtrTy);
3571 } else {
3572 values.addNullPointer(ObjCTypes.ClassPtrTy);
3573 }
3574 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3575 // Version is always 0.
3576 values.addInt(ObjCTypes.LongTy, 0);
3577 values.addInt(ObjCTypes.LongTy, Flags);
3578 values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3579 values.add(EmitIvarList(ID, false));
3580 values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3581 Methods[InstanceMethods]));
3582 // cache is always NULL.
3583 values.addNullPointer(ObjCTypes.CachePtrTy);
3584 values.add(Protocols);
3585 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3586 values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3587 /*isMetaclass*/ false));
3588
3589 std::string Name("OBJC_CLASS_");
3590 Name += ClassName;
3591 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3592 // Check for a forward reference.
3593 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3594 if (GV) {
3595 assert(GV->getValueType() == ObjCTypes.ClassTy &&
3596 "Forward metaclass reference has incorrect type.");
3597 values.finishAndSetAsInitializer(GV);
3598 GV->setSection(Section);
3599 GV->setAlignment(CGM.getPointerAlign().getAsAlign());
3600 CGM.addCompilerUsedGlobal(GV);
3601 } else
3602 GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3603 DefinedClasses.push_back(GV);
3604 ImplementedClasses.push_back(Interface);
3605 // method definition entries must be clear for next implementation.
3606 MethodDefinitions.clear();
3607}
3608
3609llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3610 llvm::Constant *Protocols,
3612 unsigned Flags = FragileABI_Class_Meta;
3613 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3614
3615 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3616 Flags |= FragileABI_Class_Hidden;
3617
3618 ConstantInitBuilder builder(CGM);
3619 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3620 // The isa for the metaclass is the root of the hierarchy.
3621 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3622 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3623 Root = Super;
3624 values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3625 ObjCTypes.ClassPtrTy);
3626 // The super class for the metaclass is emitted as the name of the
3627 // super class. The runtime fixes this up to point to the
3628 // *metaclass* for the super class.
3629 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3630 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3631 ObjCTypes.ClassPtrTy);
3632 } else {
3633 values.addNullPointer(ObjCTypes.ClassPtrTy);
3634 }
3635 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3636 // Version is always 0.
3637 values.addInt(ObjCTypes.LongTy, 0);
3638 values.addInt(ObjCTypes.LongTy, Flags);
3639 values.addInt(ObjCTypes.LongTy, Size);
3640 values.add(EmitIvarList(ID, true));
3641 values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3642 Methods));
3643 // cache is always NULL.
3644 values.addNullPointer(ObjCTypes.CachePtrTy);
3645 values.add(Protocols);
3646 // ivar_layout for metaclass is always NULL.
3647 values.addNullPointer(ObjCTypes.Int8PtrTy);
3648 // The class extension is used to store class properties for metaclasses.
3649 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3650 /*isMetaclass*/true));
3651
3652 std::string Name("OBJC_METACLASS_");
3653 Name += ID->getName();
3654
3655 // Check for a forward reference.
3656 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3657 if (GV) {
3658 assert(GV->getValueType() == ObjCTypes.ClassTy &&
3659 "Forward metaclass reference has incorrect type.");
3660 values.finishAndSetAsInitializer(GV);
3661 } else {
3662 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3663 /*constant*/ false,
3664 llvm::GlobalValue::PrivateLinkage);
3665 }
3666 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3667 CGM.addCompilerUsedGlobal(GV);
3668
3669 return GV;
3670}
3671
3672llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3673 std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3674
3675 // FIXME: Should we look these up somewhere other than the module. Its a bit
3676 // silly since we only generate these while processing an implementation, so
3677 // exactly one pointer would work if know when we entered/exitted an
3678 // implementation block.
3679
3680 // Check for an existing forward reference.
3681 // Previously, metaclass with internal linkage may have been defined.
3682 // pass 'true' as 2nd argument so it is returned.
3683 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3684 if (!GV)
3685 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3686 llvm::GlobalValue::PrivateLinkage, nullptr,
3687 Name);
3688
3689 assert(GV->getValueType() == ObjCTypes.ClassTy &&
3690 "Forward metaclass reference has incorrect type.");
3691 return GV;
3692}
3693
3694llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3695 std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3696 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3697
3698 if (!GV)
3699 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3700 llvm::GlobalValue::PrivateLinkage, nullptr,
3701 Name);
3702
3703 assert(GV->getValueType() == ObjCTypes.ClassTy &&
3704 "Forward class metadata reference has incorrect type.");
3705 return GV;
3706}
3707
3708/*
3709 Emit a "class extension", which in this specific context means extra
3710 data that doesn't fit in the normal fragile-ABI class structure, and
3711 has nothing to do with the language concept of a class extension.
3712
3713 struct objc_class_ext {
3714 uint32_t size;
3715 const char *weak_ivar_layout;
3716 struct _objc_property_list *properties;
3717 };
3718*/
3719llvm::Constant *
3720CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3721 CharUnits InstanceSize, bool hasMRCWeakIvars,
3722 bool isMetaclass) {
3723 // Weak ivar layout.
3724 llvm::Constant *layout;
3725 if (isMetaclass) {
3726 layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3727 } else {
3728 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3730 }
3731
3732 // Properties.
3733 llvm::Constant *propertyList =
3734 EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_")
3735 : Twine("_OBJC_$_PROP_LIST_"))
3736 + ID->getName(),
3737 ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3738
3739 // Return null if no extension bits are used.
3740 if (layout->isNullValue() && propertyList->isNullValue()) {
3741 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3742 }
3743
3744 uint64_t size =
3745 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3746
3747 ConstantInitBuilder builder(CGM);
3748 auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3749 values.addInt(ObjCTypes.IntTy, size);
3750 values.add(layout);
3751 values.add(propertyList);
3752
3753 return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3754 "__OBJC,__class_ext,regular,no_dead_strip",
3755 CGM.getPointerAlign(), true);
3756}
3757
3758/*
3759 struct objc_ivar {
3760 char *ivar_name;
3761 char *ivar_type;
3762 int ivar_offset;
3763 };
3764
3765 struct objc_ivar_list {
3766 int ivar_count;
3767 struct objc_ivar list[count];
3768 };
3769*/
3770llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3771 bool ForClass) {
3772 // When emitting the root class GCC emits ivar entries for the
3773 // actual class structure. It is not clear if we need to follow this
3774 // behavior; for now lets try and get away with not doing it. If so,
3775 // the cleanest solution would be to make up an ObjCInterfaceDecl
3776 // for the class.
3777 if (ForClass)
3778 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3779
3780 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3781
3782 ConstantInitBuilder builder(CGM);
3783 auto ivarList = builder.beginStruct();
3784 auto countSlot = ivarList.addPlaceholder();
3785 auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3786
3787 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3788 IVD; IVD = IVD->getNextIvar()) {
3789 // Ignore unnamed bit-fields.
3790 if (!IVD->getDeclName())
3791 continue;
3792
3793 auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3794 ivar.add(GetMethodVarName(IVD->getIdentifier()));
3795 ivar.add(GetMethodVarType(IVD));
3796 ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3797 ivar.finishAndAddTo(ivars);
3798 }
3799
3800 // Return null for empty list.
3801 auto count = ivars.size();
3802 if (count == 0) {
3803 ivars.abandon();
3804 ivarList.abandon();
3805 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3806 }
3807
3808 ivars.finishAndAddTo(ivarList);
3809 ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3810
3811 llvm::GlobalVariable *GV;
3812 if (ForClass)
3813 GV =
3814 CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3815 "__OBJC,__class_vars,regular,no_dead_strip",
3816 CGM.getPointerAlign(), true);
3817 else
3818 GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3819 "__OBJC,__instance_vars,regular,no_dead_strip",
3820 CGM.getPointerAlign(), true);
3821 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3822}
3823
3824/// Build a struct objc_method_description constant for the given method.
3825///
3826/// struct objc_method_description {
3827/// SEL method_name;
3828/// char *method_types;
3829/// };
3830void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3831 const ObjCMethodDecl *MD) {
3832 auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3833 description.addBitCast(GetMethodVarName(MD->getSelector()),
3834 ObjCTypes.SelectorPtrTy);
3835 description.add(GetMethodVarType(MD));
3836 description.finishAndAddTo(builder);
3837}
3838
3839/// Build a struct objc_method constant for the given method.
3840///
3841/// struct objc_method {
3842/// SEL method_name;
3843/// char *method_types;
3844/// void *method;
3845/// };
3846void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3847 const ObjCMethodDecl *MD) {
3848 llvm::Function *fn = GetMethodDefinition(MD);
3849 assert(fn && "no definition registered for method");
3850
3851 auto method = builder.beginStruct(ObjCTypes.MethodTy);
3852 method.addBitCast(GetMethodVarName(MD->getSelector()),
3853 ObjCTypes.SelectorPtrTy);
3854 method.add(GetMethodVarType(MD));
3855 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3856 method.finishAndAddTo(builder);
3857}
3858
3859/// Build a struct objc_method_list or struct objc_method_description_list,
3860/// as appropriate.
3861///
3862/// struct objc_method_list {
3863/// struct objc_method_list *obsolete;
3864/// int count;
3865/// struct objc_method methods_list[count];
3866/// };
3867///
3868/// struct objc_method_description_list {
3869/// int count;
3870/// struct objc_method_description list[count];
3871/// };
3872llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3874 StringRef prefix;
3875 StringRef section;
3876 bool forProtocol = false;
3877 switch (MLT) {
3878 case MethodListType::CategoryInstanceMethods:
3879 prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3880 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3881 forProtocol = false;
3882 break;
3883 case MethodListType::CategoryClassMethods:
3884 prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3885 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3886 forProtocol = false;
3887 break;
3888 case MethodListType::InstanceMethods:
3889 prefix = "OBJC_INSTANCE_METHODS_";
3890 section = "__OBJC,__inst_meth,regular,no_dead_strip";
3891 forProtocol = false;
3892 break;
3893 case MethodListType::ClassMethods:
3894 prefix = "OBJC_CLASS_METHODS_";
3895 section = "__OBJC,__cls_meth,regular,no_dead_strip";
3896 forProtocol = false;
3897 break;
3898 case MethodListType::ProtocolInstanceMethods:
3899 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3900 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3901 forProtocol = true;
3902 break;
3903 case MethodListType::ProtocolClassMethods:
3904 prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3905 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3906 forProtocol = true;
3907 break;
3908 case MethodListType::OptionalProtocolInstanceMethods:
3909 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3910 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3911 forProtocol = true;
3912 break;
3913 case MethodListType::OptionalProtocolClassMethods:
3914 prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3915 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3916 forProtocol = true;
3917 break;
3918 }
3919
3920 // Return null for empty list.
3921 if (methods.empty())
3922 return llvm::Constant::getNullValue(forProtocol
3923 ? ObjCTypes.MethodDescriptionListPtrTy
3924 : ObjCTypes.MethodListPtrTy);
3925
3926 // For protocols, this is an objc_method_description_list, which has
3927 // a slightly different structure.
3928 if (forProtocol) {
3929 ConstantInitBuilder builder(CGM);
3930 auto values = builder.beginStruct();
3931 values.addInt(ObjCTypes.IntTy, methods.size());
3932 auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3933 for (auto MD : methods) {
3934 emitMethodDescriptionConstant(methodArray, MD);
3935 }
3936 methodArray.finishAndAddTo(values);
3937
3938 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3939 CGM.getPointerAlign(), true);
3940 return llvm::ConstantExpr::getBitCast(GV,
3941 ObjCTypes.MethodDescriptionListPtrTy);
3942 }
3943
3944 // Otherwise, it's an objc_method_list.
3945 ConstantInitBuilder builder(CGM);
3946 auto values = builder.beginStruct();
3947 values.addNullPointer(ObjCTypes.Int8PtrTy);
3948 values.addInt(ObjCTypes.IntTy, methods.size());
3949 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
3950 for (auto MD : methods) {
3951 if (!MD->isDirectMethod())
3952 emitMethodConstant(methodArray, MD);
3953 }
3954 methodArray.finishAndAddTo(values);
3955
3956 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3957 CGM.getPointerAlign(), true);
3958 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3959}
3960
3961llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3962 const ObjCContainerDecl *CD) {
3963 llvm::Function *Method;
3964
3965 if (OMD->isDirectMethod()) {
3966 Method = GenerateDirectMethod(OMD, CD);
3967 } else {
3968 auto Name = getSymbolNameForMethod(OMD);
3969
3970 CodeGenTypes &Types = CGM.getTypes();
3971 llvm::FunctionType *MethodTy =
3972 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
3973 Method =
3974 llvm::Function::Create(MethodTy, llvm::GlobalValue::InternalLinkage,
3975 Name, &CGM.getModule());
3976 }
3977
3978 MethodDefinitions.insert(std::make_pair(OMD, Method));
3979
3980 return Method;
3981}
3982
3983llvm::Function *
3984CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD,
3985 const ObjCContainerDecl *CD) {
3986 auto *COMD = OMD->getCanonicalDecl();
3987 auto I = DirectMethodDefinitions.find(COMD);
3988 llvm::Function *OldFn = nullptr, *Fn = nullptr;
3989
3990 if (I != DirectMethodDefinitions.end()) {
3991 // Objective-C allows for the declaration and implementation types
3992 // to differ slightly.
3993 //
3994 // If we're being asked for the Function associated for a method
3995 // implementation, a previous value might have been cached
3996 // based on the type of the canonical declaration.
3997 //
3998 // If these do not match, then we'll replace this function with
3999 // a new one that has the proper type below.
4000 if (!OMD->getBody() || COMD->getReturnType() == OMD->getReturnType())
4001 return I->second;
4002 OldFn = I->second;
4003 }
4004
4005 CodeGenTypes &Types = CGM.getTypes();
4006 llvm::FunctionType *MethodTy =
4007 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4008
4009 if (OldFn) {
4010 Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4011 "", &CGM.getModule());
4012 Fn->takeName(OldFn);
4013 OldFn->replaceAllUsesWith(
4014 llvm::ConstantExpr::getBitCast(Fn, OldFn->getType()));
4015 OldFn->eraseFromParent();
4016
4017 // Replace the cached function in the map.
4018 I->second = Fn;
4019 } else {
4020 auto Name = getSymbolNameForMethod(OMD, /*include category*/ false);
4021
4022 Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4023 Name, &CGM.getModule());
4024 DirectMethodDefinitions.insert(std::make_pair(COMD, Fn));
4025 }
4026
4027 return Fn;
4028}
4029
4030void CGObjCCommonMac::GenerateDirectMethodPrologue(
4031 CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
4032 const ObjCContainerDecl *CD) {
4033 auto &Builder = CGF.Builder;
4034 bool ReceiverCanBeNull = true;
4035 auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
4036 auto selfValue = Builder.CreateLoad(selfAddr);
4037
4038 // Generate:
4039 //
4040 // /* for class methods only to force class lazy initialization */
4041 // self = [self self];
4042 //
4043 // /* unless the receiver is never NULL */
4044 // if (self == nil) {
4045 // return (ReturnType){ };
4046 // }
4047 //
4048 // _cmd = @selector(...)
4049 // ...
4050
4051 if (OMD->isClassMethod()) {
4052 const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
4053 assert(OID &&
4054 "GenerateDirectMethod() should be called with the Class Interface");
4055 Selector SelfSel = GetNullarySelector("self", CGM.getContext());
4056 auto ResultType = CGF.getContext().getObjCIdType();
4057 RValue result;
4058 CallArgList Args;
4059
4060 // TODO: If this method is inlined, the caller might know that `self` is
4061 // already initialized; for example, it might be an ordinary Objective-C
4062 // method which always receives an initialized `self`, or it might have just
4063 // forced initialization on its own.
4064 //
4065 // We should find a way to eliminate this unnecessary initialization in such
4066 // cases in LLVM.
4067 result = GeneratePossiblySpecializedMessageSend(
4068 CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
4069 nullptr, true);
4070 Builder.CreateStore(result.getScalarVal(), selfAddr);
4071
4072 // Nullable `Class` expressions cannot be messaged with a direct method
4073 // so the only reason why the receive can be null would be because
4074 // of weak linking.
4075 ReceiverCanBeNull = isWeakLinkedClass(OID);
4076 }
4077
4078 if (ReceiverCanBeNull) {
4079 llvm::BasicBlock *SelfIsNilBlock =
4080 CGF.createBasicBlock("objc_direct_method.self_is_nil");
4081 llvm::BasicBlock *ContBlock =
4082 CGF.createBasicBlock("objc_direct_method.cont");
4083
4084 // if (self == nil) {
4085 auto selfTy = cast<llvm::PointerType>(selfValue->getType());
4086 auto Zero = llvm::ConstantPointerNull::get(selfTy);
4087
4088 llvm::MDBuilder MDHelper(CGM.getLLVMContext());
4089 Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock,
4090 ContBlock, MDHelper.createBranchWeights(1, 1 << 20));
4091
4092 CGF.EmitBlock(SelfIsNilBlock);
4093
4094 // return (ReturnType){ };
4095 auto retTy = OMD->getReturnType();
4096 Builder.SetInsertPoint(SelfIsNilBlock);
4097 if (!retTy->isVoidType()) {
4098 CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
4099 }
4101 // }
4102
4103 // rest of the body
4104 CGF.EmitBlock(ContBlock);
4105 Builder.SetInsertPoint(ContBlock);
4106 }
4107
4108 // only synthesize _cmd if it's referenced
4109 if (OMD->getCmdDecl()->isUsed()) {
4110 // `_cmd` is not a parameter to direct methods, so storage must be
4111 // explicitly declared for it.
4112 CGF.EmitVarDecl(*OMD->getCmdDecl());
4113 Builder.CreateStore(GetSelector(CGF, OMD),
4114 CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
4115 }
4116}
4117
4118llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4120 StringRef Section,
4121 CharUnits Align,
4122 bool AddToUsed) {
4123 llvm::GlobalValue::LinkageTypes LT =
4124 getLinkageTypeForObjCMetadata(CGM, Section);
4125 llvm::GlobalVariable *GV =
4126 Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT);
4127 if (!Section.empty())
4128 GV->setSection(Section);
4129 if (AddToUsed)
4130 CGM.addCompilerUsedGlobal(GV);
4131 return GV;
4132}
4133
4134llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4135 llvm::Constant *Init,
4136 StringRef Section,
4137 CharUnits Align,
4138 bool AddToUsed) {
4139 llvm::Type *Ty = Init->getType();
4140 llvm::GlobalValue::LinkageTypes LT =
4141 getLinkageTypeForObjCMetadata(CGM, Section);
4142 llvm::GlobalVariable *GV =
4143 new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name);
4144 if (!Section.empty())
4145 GV->setSection(Section);
4146 GV->setAlignment(Align.getAsAlign());
4147 if (AddToUsed)
4148 CGM.addCompilerUsedGlobal(GV);
4149 return GV;
4150}
4151
4152llvm::GlobalVariable *
4153CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
4154 bool ForceNonFragileABI,
4155 bool NullTerminate) {
4156 StringRef Label;
4157 switch (Type) {
4158 case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break;
4159 case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
4160 case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
4161 case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break;
4162 }
4163
4164 bool NonFragile = ForceNonFragileABI || isNonFragileABI();
4165
4166 StringRef Section;
4167 switch (Type) {
4168 case ObjCLabelType::ClassName:
4169 Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
4170 : "__TEXT,__cstring,cstring_literals";
4171 break;
4172 case ObjCLabelType::MethodVarName:
4173 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4174 : "__TEXT,__cstring,cstring_literals";
4175 break;
4176 case ObjCLabelType::MethodVarType:
4177 Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
4178 : "__TEXT,__cstring,cstring_literals";
4179 break;
4180 case ObjCLabelType::PropertyName:
4181 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4182 : "__TEXT,__cstring,cstring_literals";
4183 break;
4184 }
4185
4186 llvm::Constant *Value =
4187 llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
4188 llvm::GlobalVariable *GV =
4189 new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
4190 /*isConstant=*/true,
4191 llvm::GlobalValue::PrivateLinkage, Value, Label);
4192 if (CGM.getTriple().isOSBinFormatMachO())
4193 GV->setSection(Section);
4194 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4195 GV->setAlignment(CharUnits::One().getAsAlign());
4196 CGM.addCompilerUsedGlobal(GV);
4197
4198 return GV;
4199}
4200
4201llvm::Function *CGObjCMac::ModuleInitFunction() {
4202 // Abuse this interface function as a place to finalize.
4203 FinishModule();
4204 return nullptr;
4205}
4206
4207llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() {
4208 return ObjCTypes.getGetPropertyFn();
4209}
4210
4211llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() {
4212 return ObjCTypes.getSetPropertyFn();
4213}
4214
4215llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4216 bool copy) {
4217 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4218}
4219
4220llvm::FunctionCallee CGObjCMac::GetGetStructFunction() {
4221 return ObjCTypes.getCopyStructFn();
4222}
4223
4224llvm::FunctionCallee CGObjCMac::GetSetStructFunction() {
4225 return ObjCTypes.getCopyStructFn();
4226}
4227
4228llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() {
4229 return ObjCTypes.getCppAtomicObjectFunction();
4230}
4231
4232llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() {
4233 return ObjCTypes.getCppAtomicObjectFunction();
4234}
4235
4236llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() {
4237 return ObjCTypes.getEnumerationMutationFn();
4238}
4239
4240void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4241 return EmitTryOrSynchronizedStmt(CGF, S);
4242}
4243
4244void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4245 const ObjCAtSynchronizedStmt &S) {
4246 return EmitTryOrSynchronizedStmt(CGF, S);
4247}
4248
4249namespace {
4250 struct PerformFragileFinally final : EHScopeStack::Cleanup {
4251 const Stmt &S;
4252 Address SyncArgSlot;
4253 Address CallTryExitVar;
4254 Address ExceptionData;
4255 ObjCTypesHelper &ObjCTypes;
4256 PerformFragileFinally(const Stmt *S,
4257 Address SyncArgSlot,
4258 Address CallTryExitVar,
4259 Address ExceptionData,
4260 ObjCTypesHelper *ObjCTypes)
4261 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4262 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4263
4264 void Emit(CodeGenFunction &CGF, Flags flags) override {
4265 // Check whether we need to call objc_exception_try_exit.
4266 // In optimized code, this branch will always be folded.
4267 llvm::BasicBlock *FinallyCallExit =
4268 CGF.createBasicBlock("finally.call_exit");
4269 llvm::BasicBlock *FinallyNoCallExit =
4270 CGF.createBasicBlock("finally.no_call_exit");
4271 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4272 FinallyCallExit, FinallyNoCallExit);
4273
4274 CGF.EmitBlock(FinallyCallExit);
4275 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4276 ExceptionData.getPointer());
4277
4278 CGF.EmitBlock(FinallyNoCallExit);
4279
4280 if (isa<ObjCAtTryStmt>(S)) {
4281 if (const ObjCAtFinallyStmt* FinallyStmt =
4282 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4283 // Don't try to do the @finally if this is an EH cleanup.
4284 if (flags.isForEHCleanup()) return;
4285
4286 // Save the current cleanup destination in case there's
4287 // control flow inside the finally statement.
4288 llvm::Value *CurCleanupDest =
4290
4291 CGF.EmitStmt(FinallyStmt->getFinallyBody());
4292
4293 if (CGF.HaveInsertPoint()) {
4294 CGF.Builder.CreateStore(CurCleanupDest,
4296 } else {
4297 // Currently, the end of the cleanup must always exist.
4298 CGF.EnsureInsertPoint();
4299 }
4300 }
4301 } else {
4302 // Emit objc_sync_exit(expr); as finally's sole statement for
4303 // @synchronized.
4304 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4305 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4306 }
4307 }
4308 };
4309
4310 class FragileHazards {
4311 CodeGenFunction &CGF;
4313 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4314
4315 llvm::InlineAsm *ReadHazard;
4316 llvm::InlineAsm *WriteHazard;
4317
4318 llvm::FunctionType *GetAsmFnType();
4319
4320 void collectLocals();
4321 void emitReadHazard(CGBuilderTy &Builder);
4322
4323 public:
4324 FragileHazards(CodeGenFunction &CGF);
4325
4326 void emitWriteHazard();
4327 void emitHazardsInNewBlocks();
4328 };
4329} // end anonymous namespace
4330
4331/// Create the fragile-ABI read and write hazards based on the current
4332/// state of the function, which is presumed to be immediately prior
4333/// to a @try block. These hazards are used to maintain correct
4334/// semantics in the face of optimization and the fragile ABI's
4335/// cavalier use of setjmp/longjmp.
4336FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4337 collectLocals();
4338
4339 if (Locals.empty()) return;
4340
4341 // Collect all the blocks in the function.
4342 for (llvm::Function::iterator
4343 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4344 BlocksBeforeTry.insert(&*I);
4345
4346 llvm::FunctionType *AsmFnTy = GetAsmFnType();
4347
4348 // Create a read hazard for the allocas. This inhibits dead-store
4349 // optimizations and forces the values to memory. This hazard is
4350 // inserted before any 'throwing' calls in the protected scope to
4351 // reflect the possibility that the variables might be read from the
4352 // catch block if the call throws.
4353 {
4354 std::string Constraint;
4355 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4356 if (I) Constraint += ',';
4357 Constraint += "*m";
4358 }
4359
4360 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4361 }
4362
4363 // Create a write hazard for the allocas. This inhibits folding
4364 // loads across the hazard. This hazard is inserted at the
4365 // beginning of the catch path to reflect the possibility that the
4366 // variables might have been written within the protected scope.
4367 {
4368 std::string Constraint;
4369 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4370 if (I) Constraint += ',';
4371 Constraint += "=*m";
4372 }
4373
4374 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4375 }
4376}
4377
4378/// Emit a write hazard at the current location.
4379void FragileHazards::emitWriteHazard() {
4380 if (Locals.empty()) return;
4381
4382 llvm::CallInst *Call = CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4383 for (auto Pair : llvm::enumerate(Locals))
4384 Call->addParamAttr(Pair.index(), llvm::Attribute::get(
4385 CGF.getLLVMContext(), llvm::Attribute::ElementType,
4386 cast<llvm::AllocaInst>(Pair.value())->getAllocatedType()));
4387}
4388
4389void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4390 assert(!Locals.empty());
4391 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4392 call->setDoesNotThrow();
4393 call->setCallingConv(CGF.getRuntimeCC());
4394 for (auto Pair : llvm::enumerate(Locals))
4395 call->addParamAttr(Pair.index(), llvm::Attribute::get(
4396 Builder.getContext(), llvm::Attribute::ElementType,
4397 cast<llvm::AllocaInst>(Pair.value())->getAllocatedType()));
4398}
4399
4400/// Emit read hazards in all the protected blocks, i.e. all the blocks
4401/// which have been inserted since the beginning of the try.
4402void FragileHazards::emitHazardsInNewBlocks() {
4403 if (Locals.empty()) return;
4404
4405 CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4406
4407 // Iterate through all blocks, skipping those prior to the try.
4408 for (llvm::Function::iterator
4409 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4410 llvm::BasicBlock &BB = *FI;
4411 if (BlocksBeforeTry.count(&BB)) continue;
4412
4413 // Walk through all the calls in the block.
4414 for (llvm::BasicBlock::iterator
4415 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4416 llvm::Instruction &I = *BI;
4417
4418 // Ignore instructions that aren't non-intrinsic calls.
4419 // These are the only calls that can possibly call longjmp.
4420 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I))
4421 continue;
4422 if (isa<llvm::IntrinsicInst>(I))
4423 continue;
4424
4425 // Ignore call sites marked nounwind. This may be questionable,
4426 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4427 if (cast<llvm::CallBase>(I).doesNotThrow())
4428 continue;
4429
4430 // Insert a read hazard before the call. This will ensure that
4431 // any writes to the locals are performed before making the
4432 // call. If the call throws, then this is sufficient to
4433 // guarantee correctness as long as it doesn't also write to any
4434 // locals.
4435 Builder.SetInsertPoint(&BB, BI);
4436 emitReadHazard(Builder);
4437 }
4438 }
4439}
4440
4442 if (V.isValid()) S.insert(V.getPointer());
4443}
4444
4445void FragileHazards::collectLocals() {
4446 // Compute a set of allocas to ignore.
4447 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4448 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4449 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4450
4451 // Collect all the allocas currently in the function. This is
4452 // probably way too aggressive.
4453 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4454 for (llvm::BasicBlock::iterator
4455 I = Entry.begin(), E = Entry.end(); I != E; ++I)
4456 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4457 Locals.push_back(&*I);
4458}
4459
4460llvm::FunctionType *FragileHazards::GetAsmFnType() {
4461 SmallVector<llvm::Type *, 16> tys(Locals.size());
4462 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4463 tys[i] = Locals[i]->getType();
4464 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4465}
4466
4467/*
4468
4469 Objective-C setjmp-longjmp (sjlj) Exception Handling
4470 --
4471
4472 A catch buffer is a setjmp buffer plus:
4473 - a pointer to the exception that was caught
4474 - a pointer to the previous exception data buffer
4475 - two pointers of reserved storage
4476 Therefore catch buffers form a stack, with a pointer to the top
4477 of the stack kept in thread-local storage.
4478
4479 objc_exception_try_enter pushes a catch buffer onto the EH stack.
4480 objc_exception_try_exit pops the given catch buffer, which is
4481 required to be the top of the EH stack.
4482 objc_exception_throw pops the top of the EH stack, writes the
4483 thrown exception into the appropriate field, and longjmps
4484 to the setjmp buffer. It crashes the process (with a printf
4485 and an abort()) if there are no catch buffers on the stack.
4486 objc_exception_extract just reads the exception pointer out of the
4487 catch buffer.
4488
4489 There's no reason an implementation couldn't use a light-weight
4490 setjmp here --- something like __builtin_setjmp, but API-compatible
4491 with the heavyweight setjmp. This will be more important if we ever
4492 want to implement correct ObjC/C++ exception interactions for the
4493 fragile ABI.
4494
4495 Note that for this use of setjmp/longjmp to be correct, we may need
4496 to mark some local variables volatile: if a non-volatile local
4497 variable is modified between the setjmp and the longjmp, it has
4498 indeterminate value. For the purposes of LLVM IR, it may be
4499 sufficient to make loads and stores within the @try (to variables
4500 declared outside the @try) volatile. This is necessary for
4501 optimized correctness, but is not currently being done; this is
4502 being tracked as rdar://problem/8160285
4503
4504 The basic framework for a @try-catch-finally is as follows:
4505 {
4506 objc_exception_data d;
4507 id _rethrow = null;
4508 bool _call_try_exit = true;
4509
4510 objc_exception_try_enter(&d);
4511 if (!setjmp(d.jmp_buf)) {
4512 ... try body ...
4513 } else {
4514 // exception path
4515 id _caught = objc_exception_extract(&d);
4516
4517 // enter new try scope for handlers
4518 if (!setjmp(d.jmp_buf)) {
4519 ... match exception and execute catch blocks ...
4520
4521 // fell off end, rethrow.
4522 _rethrow = _caught;
4523 ... jump-through-finally to finally_rethrow ...
4524 } else {
4525 // exception in catch block
4526 _rethrow = objc_exception_extract(&d);
4527 _call_try_exit = false;
4528 ... jump-through-finally to finally_rethrow ...
4529 }
4530 }
4531 ... jump-through-finally to finally_end ...
4532
4533 finally:
4534 if (_call_try_exit)
4535 objc_exception_try_exit(&d);
4536
4537 ... finally block ....
4538 ... dispatch to finally destination ...
4539
4540 finally_rethrow:
4541 objc_exception_throw(_rethrow);
4542
4543 finally_end:
4544 }
4545
4546 This framework differs slightly from the one gcc uses, in that gcc
4547 uses _rethrow to determine if objc_exception_try_exit should be called
4548 and if the object should be rethrown. This breaks in the face of
4549 throwing nil and introduces unnecessary branches.
4550
4551 We specialize this framework for a few particular circumstances:
4552
4553 - If there are no catch blocks, then we avoid emitting the second
4554 exception handling context.
4555
4556 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4557 e)) we avoid emitting the code to rethrow an uncaught exception.
4558
4559 - FIXME: If there is no @finally block we can do a few more
4560 simplifications.
4561
4562 Rethrows and Jumps-Through-Finally
4563 --
4564
4565 '@throw;' is supported by pushing the currently-caught exception
4566 onto ObjCEHStack while the @catch blocks are emitted.
4567
4568 Branches through the @finally block are handled with an ordinary
4569 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4570 exceptions are not compatible with C++ exceptions, and this is
4571 hardly the only place where this will go wrong.
4572
4573 @synchronized(expr) { stmt; } is emitted as if it were:
4574 id synch_value = expr;
4575 objc_sync_enter(synch_value);
4576 @try { stmt; } @finally { objc_sync_exit(synch_value); }
4577*/
4578
4579void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4580 const Stmt &S) {
4581 bool isTry = isa<ObjCAtTryStmt>(S);
4582
4583 // A destination for the fall-through edges of the catch handlers to
4584 // jump to.
4585 CodeGenFunction::JumpDest FinallyEnd =
4586 CGF.getJumpDestInCurrentScope("finally.end");
4587
4588 // A destination for the rethrow edge of the catch handlers to jump
4589 // to.
4590 CodeGenFunction::JumpDest FinallyRethrow =
4591 CGF.getJumpDestInCurrentScope("finally.rethrow");
4592
4593 // For @synchronized, call objc_sync_enter(sync.expr). The
4594 // evaluation of the expression must occur before we enter the
4595 // @synchronized. We can't avoid a temp here because we need the
4596 // value to be preserved. If the backend ever does liveness
4597 // correctly after setjmp, this will be unnecessary.
4598 Address SyncArgSlot = Address::invalid();
4599 if (!isTry) {
4600 llvm::Value *SyncArg =
4601 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4602 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4603 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4604
4605 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4606 CGF.getPointerAlign(), "sync.arg");
4607 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4608 }
4609
4610 // Allocate memory for the setjmp buffer. This needs to be kept
4611 // live throughout the try and catch blocks.
4612 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4613 CGF.getPointerAlign(),
4614 "exceptiondata.ptr");
4615
4616 // Create the fragile hazards. Note that this will not capture any
4617 // of the allocas required for exception processing, but will
4618 // capture the current basic block (which extends all the way to the
4619 // setjmp call) as "before the @try".
4620 FragileHazards Hazards(CGF);
4621
4622 // Create a flag indicating whether the cleanup needs to call
4623 // objc_exception_try_exit. This is true except when
4624 // - no catches match and we're branching through the cleanup
4625 // just to rethrow the exception, or
4626 // - a catch matched and we're falling out of the catch handler.
4627 // The setjmp-safety rule here is that we should always store to this
4628 // variable in a place that dominates the branch through the cleanup
4629 // without passing through any setjmps.
4630 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4632 "_call_try_exit");
4633
4634 // A slot containing the exception to rethrow. Only needed when we
4635 // have both a @catch and a @finally.
4636 Address PropagatingExnVar = Address::invalid();
4637
4638 // Push a normal cleanup to leave the try scope.
4639 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4640 SyncArgSlot,
4641 CallTryExitVar,
4642 ExceptionData,
4643 &ObjCTypes);
4644
4645 // Enter a try block:
4646 // - Call objc_exception_try_enter to push ExceptionData on top of
4647 // the EH stack.
4648 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4649 ExceptionData.getPointer());
4650
4651 // - Call setjmp on the exception data buffer.
4652 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4653 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4654 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4655 ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4656 "setjmp_buffer");
4657 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4658 ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4659 SetJmpResult->setCanReturnTwice();
4660
4661 // If setjmp returned 0, enter the protected block; otherwise,
4662 // branch to the handler.
4663 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4664 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4665 llvm::Value *DidCatch =
4666 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4667 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4668
4669 // Emit the protected block.
4670 CGF.EmitBlock(TryBlock);
4671 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4672 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4673 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4674
4675 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4676
4677 // Emit the exception handler block.
4678 CGF.EmitBlock(TryHandler);
4679
4680 // Don't optimize loads of the in-scope locals across this point.
4681 Hazards.emitWriteHazard();
4682
4683 // For a @synchronized (or a @try with no catches), just branch
4684 // through the cleanup to the rethrow block.
4685 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4686 // Tell the cleanup not to re-pop the exit.
4687 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4688 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4689
4690 // Otherwise, we have to match against the caught exceptions.
4691 } else {
4692 // Retrieve the exception object. We may emit multiple blocks but
4693 // nothing can cross this so the value is already in SSA form.
4694 llvm::CallInst *Caught =
4695 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4696 ExceptionData.getPointer(), "caught");
4697
4698 // Push the exception to rethrow onto the EH value stack for the
4699 // benefit of any @throws in the handlers.
4700 CGF.ObjCEHValueStack.push_back(Caught);
4701
4702 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4703
4704 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4705
4706 llvm::BasicBlock *CatchBlock = nullptr;
4707 llvm::BasicBlock *CatchHandler = nullptr;
4708 if (HasFinally) {
4709 // Save the currently-propagating exception before
4710 // objc_exception_try_enter clears the exception slot.
4711 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4712 CGF.getPointerAlign(),
4713 "propagating_exception");
4714 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4715
4716 // Enter a new exception try block (in case a @catch block
4717 // throws an exception).
4718 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4719 ExceptionData.getPointer());
4720
4721 llvm::CallInst *SetJmpResult =
4722 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4723 SetJmpBuffer, "setjmp.result");
4724 SetJmpResult->setCanReturnTwice();
4725
4726 llvm::Value *Threw =
4727 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4728
4729 CatchBlock = CGF.createBasicBlock("catch");
4730 CatchHandler = CGF.createBasicBlock("catch_for_catch");
4731 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4732
4733 CGF.EmitBlock(CatchBlock);
4734 }
4735
4736 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4737
4738 // Handle catch list. As a special case we check if everything is
4739 // matched and avoid generating code for falling off the end if
4740 // so.
4741 bool AllMatched = false;
4742 for (const ObjCAtCatchStmt *CatchStmt : AtTryStmt->catch_stmts()) {
4743 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4744 const ObjCObjectPointerType *OPT = nullptr;
4745
4746 // catch(...) always matches.
4747 if (!CatchParam) {
4748 AllMatched = true;
4749 } else {
4750 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4751
4752 // catch(id e) always matches under this ABI, since only
4753 // ObjC exceptions end up here in the first place.
4754 // FIXME: For the time being we also match id<X>; this should
4755 // be rejected by Sema instead.
4756 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4757 AllMatched = true;
4758 }
4759
4760 // If this is a catch-all, we don't need to test anything.
4761 if (AllMatched) {
4762 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4763
4764 if (CatchParam) {
4765 CGF.EmitAutoVarDecl(*CatchParam);
4766 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4767
4768 // These types work out because ConvertType(id) == i8*.
4769 EmitInitOfCatchParam(CGF, Caught, CatchParam);
4770 }
4771
4772 CGF.EmitStmt(CatchStmt->getCatchBody());
4773
4774 // The scope of the catch variable ends right here.
4775 CatchVarCleanups.ForceCleanup();
4776
4777 CGF.EmitBranchThroughCleanup(FinallyEnd);
4778 break;
4779 }
4780
4781 assert(OPT && "Unexpected non-object pointer type in @catch");
4782 const ObjCObjectType *ObjTy = OPT->getObjectType();
4783
4784 // FIXME: @catch (Class c) ?
4785 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4786 assert(IDecl && "Catch parameter must have Objective-C type!");
4787
4788 // Check if the @catch block matches the exception object.
4789 llvm::Value *Class = EmitClassRef(CGF, IDecl);
4790
4791 llvm::Value *matchArgs[] = { Class, Caught };
4792 llvm::CallInst *Match =
4793 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4794 matchArgs, "match");
4795
4796 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4797 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4798
4799 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4800 MatchedBlock, NextCatchBlock);
4801
4802 // Emit the @catch block.
4803 CGF.EmitBlock(MatchedBlock);
4804
4805 // Collect any cleanups for the catch variable. The scope lasts until
4806 // the end of the catch body.
4807 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4808
4809 CGF.EmitAutoVarDecl(*CatchParam);
4810 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4811
4812 // Initialize the catch variable.
4813 llvm::Value *Tmp =
4814 CGF.Builder.CreateBitCast(Caught,
4815 CGF.ConvertType(CatchParam->getType()));
4816 EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4817
4818 CGF.EmitStmt(CatchStmt->getCatchBody());
4819
4820 // We're done with the catch variable.
4821 CatchVarCleanups.ForceCleanup();
4822
4823 CGF.EmitBranchThroughCleanup(FinallyEnd);
4824
4825 CGF.EmitBlock(NextCatchBlock);
4826 }
4827
4828 CGF.ObjCEHValueStack.pop_back();
4829
4830 // If nothing wanted anything to do with the caught exception,
4831 // kill the extract call.
4832 if (Caught->use_empty())
4833 Caught->eraseFromParent();
4834
4835 if (!AllMatched)
4836 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4837
4838 if (HasFinally) {
4839 // Emit the exception handler for the @catch blocks.
4840 CGF.EmitBlock(CatchHandler);
4841
4842 // In theory we might now need a write hazard, but actually it's
4843 // unnecessary because there's no local-accessing code between
4844 // the try's write hazard and here.
4845 //Hazards.emitWriteHazard();
4846
4847 // Extract the new exception and save it to the
4848 // propagating-exception slot.
4849 assert(PropagatingExnVar.isValid());
4850 llvm::CallInst *NewCaught =
4851 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4852 ExceptionData.getPointer(), "caught");
4853 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4854
4855 // Don't pop the catch handler; the throw already did.
4856 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4857 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4858 }
4859 }
4860
4861 // Insert read hazards as required in the new blocks.
4862 Hazards.emitHazardsInNewBlocks();
4863
4864 // Pop the cleanup.
4865 CGF.Builder.restoreIP(TryFallthroughIP);
4866 if (CGF.HaveInsertPoint())
4867 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4868 CGF.PopCleanupBlock();
4869 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4870
4871 // Emit the rethrow block.
4872 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4873 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4874 if (CGF.HaveInsertPoint()) {
4875 // If we have a propagating-exception variable, check it.
4876 llvm::Value *PropagatingExn;
4877 if (PropagatingExnVar.isValid()) {
4878 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4879
4880 // Otherwise, just look in the buffer for the exception to throw.
4881 } else {
4882 llvm::CallInst *Caught =
4883 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4884 ExceptionData.getPointer());
4885 PropagatingExn = Caught;
4886 }
4887
4888 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4889 PropagatingExn);
4890 CGF.Builder.CreateUnreachable();
4891 }
4892
4893 CGF.Builder.restoreIP(SavedIP);
4894}
4895
4896void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4897 const ObjCAtThrowStmt &S,
4898 bool ClearInsertionPoint) {
4899 llvm::Value *ExceptionAsObject;
4900
4901 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4902 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4903 ExceptionAsObject =
4904 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4905 } else {
4906 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4907 "Unexpected rethrow outside @catch block.");
4908 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4909 }
4910
4911 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4912 ->setDoesNotReturn();
4913 CGF.Builder.CreateUnreachable();
4914
4915 // Clear the insertion point to indicate we are in unreachable code.
4916 if (ClearInsertionPoint)
4917 CGF.Builder.ClearInsertionPoint();
4918}
4919
4920/// EmitObjCWeakRead - Code gen for loading value of a __weak
4921/// object: objc_read_weak (id *src)
4922///
4923llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4924 Address AddrWeakObj) {
4925 llvm::Type* DestTy = AddrWeakObj.getElementType();
4926 llvm::Value *AddrWeakObjVal = CGF.Builder.CreateBitCast(
4927 AddrWeakObj.getPointer(), ObjCTypes.PtrObjectPtrTy);
4928 llvm::Value *read_weak =
4929 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4930 AddrWeakObjVal, "weakread");
4931 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4932 return read_weak;
4933}
4934
4935/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4936/// objc_assign_weak (id src, id *dst)
4937///
4938void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4939 llvm::Value *src, Address dst) {
4940 llvm::Type * SrcTy = src->getType();
4941 if (!isa<llvm::PointerType>(SrcTy)) {
4942 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4943 assert(Size <= 8 && "does not support size > 8");
4944 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4945 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4946 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4947 }
4948 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4949 llvm::Value *dstVal =
4950 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy);
4951 llvm::Value *args[] = { src, dstVal };
4952 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4953 args, "weakassign");
4954}
4955
4956/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4957/// objc_assign_global (id src, id *dst)
4958///
4959void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4960 llvm::Value *src, Address dst,
4961 bool threadlocal) {
4962 llvm::Type * SrcTy = src->getType();
4963 if (!isa<llvm::PointerType>(SrcTy)) {
4964 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4965 assert(Size <= 8 && "does not support size > 8");
4966 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4967 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4968 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4969 }
4970 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4971 llvm::Value *dstVal =
4972 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy);
4973 llvm::Value *args[] = {src, dstVal};
4974 if (!threadlocal)
4975 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4976 args, "globalassign");
4977 else
4978 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4979 args, "threadlocalassign");
4980}
4981
4982/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4983/// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4984///
4985void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4986 llvm::Value *src, Address dst,
4987 llvm::Value *ivarOffset) {
4988 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4989 llvm::Type * SrcTy = src->getType();
4990 if (!isa<llvm::PointerType>(SrcTy)) {
4991 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4992 assert(Size <= 8 && "does not support size > 8");
4993 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4994 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4995 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4996 }
4997 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4998 llvm::Value *dstVal =
4999 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy);
5000 llvm::Value *args[] = {src, dstVal, ivarOffset};
5001 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
5002}
5003
5004/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5005/// objc_assign_strongCast (id src, id *dst)
5006///
5007void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
5008 llvm::Value *src, Address dst) {
5009 llvm::Type * SrcTy = src->getType();
5010 if (!isa<llvm::PointerType>(SrcTy)) {
5011 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5012 assert(Size <= 8 && "does not support size > 8");
5013 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5014 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5015 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5016 }
5017 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5018 llvm::Value *dstVal =
5019 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy);
5020 llvm::Value *args[] = {src, dstVal};
5021 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
5022 args, "strongassign");
5023}
5024
5025void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
5026 Address DestPtr,
5027 Address SrcPtr,
5028 llvm::Value *size) {
5029 SrcPtr = CGF.Builder.CreateElementBitCast(SrcPtr, CGF.Int8Ty);
5030 DestPtr = CGF.Builder.CreateElementBitCast(DestPtr, CGF.Int8Ty);
5031 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
5032 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
5033}
5034
5035/// EmitObjCValueForIvar - Code Gen for ivar reference.
5036///
5037LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
5038 QualType ObjectTy,
5039 llvm::Value *BaseValue,
5040 const ObjCIvarDecl *Ivar,
5041 unsigned CVRQualifiers) {
5042 const ObjCInterfaceDecl *ID =
5043 ObjectTy->castAs<ObjCObjectType>()->getInterface();
5044 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
5045 EmitIvarOffset(CGF, ID, Ivar));
5046}
5047
5048llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
5049 const ObjCInterfaceDecl *Interface,
5050 const ObjCIvarDecl *Ivar) {
5051 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
5052 return llvm::ConstantInt::get(
5053 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
5054 Offset);
5055}
5056
5057/* *** Private Interface *** */
5058
5059std::string CGObjCCommonMac::GetSectionName(StringRef Section,
5060 StringRef MachOAttributes) {
5061 switch (CGM.getTriple().getObjectFormat()) {
5062 case llvm::Triple::UnknownObjectFormat:
5063 llvm_unreachable("unexpected object file format");
5064 case llvm::Triple::MachO: {
5065 if (MachOAttributes.empty())
5066 return ("__DATA," + Section).str();
5067 return ("__DATA," + Section + "," + MachOAttributes).str();
5068 }
5069 case llvm::Triple::ELF:
5070 assert(Section.substr(0, 2) == "__" &&
5071 "expected the name to begin with __");
5072 return Section.substr(2).str();
5073 case llvm::Triple::COFF:
5074 assert(Section.substr(0, 2) == "__" &&
5075 "expected the name to begin with __");
5076 return ("." + Section.substr(2) + "$B").str();
5077 case llvm::Triple::Wasm:
5078 case llvm::Triple::GOFF:
5079 case llvm::Triple::SPIRV:
5080 case llvm::Triple::XCOFF:
5081 case llvm::Triple::DXContainer:
5082 llvm::report_fatal_error(
5083 "Objective-C support is unimplemented for object file format");
5084 }
5085
5086 llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum");
5087}
5088
5089/// EmitImageInfo - Emit the image info marker used to encode some module
5090/// level information.
5091///
5092/// See: <rdr://4810609&4810587&4810587>
5093/// struct IMAGE_INFO {
5094/// unsigned version;
5095/// unsigned flags;
5096/// };
5097enum ImageInfoFlags {
5098 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
5099 eImageInfo_GarbageCollected = (1 << 1),
5100 eImageInfo_GCOnly = (1 << 2),
5101 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
5102
5103 // A flag indicating that the module has no instances of a @synthesize of a
5104 // superclass variable. <rdar://problem/6803242>
5105 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
5106 eImageInfo_ImageIsSimulated = (1 << 5),
5107 eImageInfo_ClassProperties = (1 << 6)
5109
5110void CGObjCCommonMac::EmitImageInfo() {
5111 unsigned version = 0; // Version is unused?
5112 std::string Section =
5113 (ObjCABI == 1)
5114 ? "__OBJC,__image_info,regular"
5115 : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
5116
5117 // Generate module-level named metadata to convey this information to the
5118 // linker and code-gen.
5119 llvm::Module &Mod = CGM.getModule();
5120
5121 // Add the ObjC ABI version to the module flags.
5122 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
5123 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
5124 version);
5125 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
5126 llvm::MDString::get(VMContext, Section));
5127
5128 auto Int8Ty = llvm::Type::getInt8Ty(VMContext);
5129 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5130 // Non-GC overrides those files which specify GC.
5131 Mod.addModuleFlag(llvm::Module::Error,
5132 "Objective-C Garbage Collection",
5133 llvm::ConstantInt::get(Int8Ty,0));
5134 } else {
5135 // Add the ObjC garbage collection value.
5136 Mod.addModuleFlag(llvm::Module::Error,
5137 "Objective-C Garbage Collection",
5138 llvm::ConstantInt::get(Int8Ty,
5139 (uint8_t)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 Int8Ty, 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
5174static const int ModuleVersion = 7;
5175
5176void 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
5191llvm::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
5230llvm::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->getValueType(), Entry,
5247 CGF.getPointerAlign());
5248}
5249
5250llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
5251 const ObjCInterfaceDecl *ID) {
5252 // If the class has the objc_runtime_visible attribute, we need to
5253 // use the Objective-C runtime to get the class.
5254 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
5255 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
5256
5257 IdentifierInfo *RuntimeName =
5258 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
5259 return EmitClassRefFromId(CGF, RuntimeName);
5260}
5261
5262llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
5263 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
5264 return EmitClassRefFromId(CGF, II);
5265}
5266
5267llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
5268 return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel));
5269}
5270
5271Address CGObjCMac::EmitSelectorAddr(Selector Sel) {
5272 CharUnits Align = CGM.getPointerAlign();
5273
5274 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5275 if (!Entry) {
5276 llvm::Constant *Casted =
5277 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5278 ObjCTypes.SelectorPtrTy);
5279 Entry = CreateMetadataVar(
5280 "OBJC_SELECTOR_REFERENCES_", Casted,
5281 "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5282 Entry->setExternallyInitialized(true);
5283 }
5284
5285 return Address(Entry, ObjCTypes.SelectorPtrTy, Align);
5286}
5287
5288llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5289 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5290 if (!Entry)
5291 Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5292 return getConstantGEP(VMContext, Entry, 0, 0);
5293}
5294
5295llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5296 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5297 I = MethodDefinitions.find(MD);
5298 if (I != MethodDefinitions.end())
5299 return I->second;
5300
5301 return nullptr;
5302}
5303
5304/// GetIvarLayoutName - Returns a unique constant for the given
5305/// ivar layout bitmap.
5306llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5307 const ObjCCommonTypesHelper &ObjCTypes) {
5308 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5309}
5310
5311void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5312 CharUnits offset) {
5313 const RecordDecl *RD = RT->getDecl();
5314
5315 // If this is a union, remember that we had one, because it might mess
5316 // up the ordering of layout entries.
5317 if (RD->isUnion())
5318 IsDisordered = true;
5319
5320 const ASTRecordLayout *recLayout = nullptr;
5321 visitAggregate(RD->field_begin(), RD->field_end(), offset,
5322 [&](const FieldDecl *field) -> CharUnits {
5323 if (!recLayout)
5324 recLayout = &CGM.getContext().getASTRecordLayout(RD);
5325 auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5326 return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5327 });
5328}
5329
5330template <class Iterator, class GetOffsetFn>
5331void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5332 CharUnits aggregateOffset,
5333 const GetOffsetFn &getOffset) {
5334 for (; begin != end; ++begin) {
5335 auto field = *begin;
5336
5337 // Skip over bitfields.
5338 if (field->isBitField()) {
5339 continue;
5340 }
5341
5342 // Compute the offset of the field within the aggregate.
5343 CharUnits fieldOffset = aggregateOffset + getOffset(field);
5344
5345 visitField(field, fieldOffset);
5346 }
5347}
5348
5349/// Collect layout information for the given fields into IvarsInfo.
5350void IvarLayoutBuilder::visitField(const FieldDecl *field,
5351 CharUnits fieldOffset) {
5352 QualType fieldType = field->getType();
5353
5354 // Drill down into arrays.
5355 uint64_t numElts = 1;
5356 if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5357 numElts = 0;
5358 fieldType = arrayType->getElementType();
5359 }
5360 // Unlike incomplete arrays, constant arrays can be nested.
5361 while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5362 numElts *= arrayType->getSize().getZExtValue();
5363 fieldType = arrayType->getElementType();
5364 }
5365
5366 assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
5367
5368 // If we ended up with a zero-sized array, we've done what we can do within
5369 // the limits of this layout encoding.
5370 if (numElts == 0) return;
5371
5372 // Recurse if the base element type is a record type.
5373 if (auto recType = fieldType->getAs<RecordType>()) {
5374 size_t oldEnd = IvarsInfo.size();
5375
5376 visitRecord(recType, fieldOffset);
5377
5378 // If we have an array, replicate the first entry's layout information.
5379 auto numEltEntries = IvarsInfo.size() - oldEnd;
5380 if (numElts != 1 && numEltEntries != 0) {
5381 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5382 for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5383 // Copy the last numEltEntries onto the end of the array, adjusting
5384 // each for the element size.
5385 for (size_t i = 0; i != numEltEntries; ++i) {
5386 auto firstEntry = IvarsInfo[oldEnd + i];
5387 IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5388 firstEntry.SizeInWords));
5389 }
5390 }
5391 }
5392
5393 return;
5394 }
5395
5396 // Classify the element type.
5397 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5398
5399 // If it matches what we're looking for, add an entry.
5400 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5401 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5402 assert(CGM.getContext().getTypeSizeInChars(fieldType)
5403 == CGM.getPointerSize());
5404 IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5405 }
5406}
5407
5408/// buildBitmap - This routine does the horsework of taking the offsets of
5409/// strong/weak references and creating a bitmap. The bitmap is also
5410/// returned in the given buffer, suitable for being passed to \c dump().
5411llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5412 llvm::SmallVectorImpl<unsigned char> &buffer) {
5413 // The bitmap is a series of skip/scan instructions, aligned to word
5414 // boundaries. The skip is performed first.
5415 const unsigned char MaxNibble = 0xF;
5416 const unsigned char SkipMask = 0xF0, SkipShift = 4;
5417 const unsigned char ScanMask = 0x0F, ScanShift = 0;
5418
5419 assert(!IvarsInfo.empty() && "generating bitmap for no data");
5420
5421 // Sort the ivar info on byte position in case we encounterred a
5422 // union nested in the ivar list.
5423 if (IsDisordered) {
5424 // This isn't a stable sort, but our algorithm should handle it fine.
5425 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5426 } else {
5427 assert(llvm::is_sorted(IvarsInfo));
5428 }
5429 assert(IvarsInfo.back().Offset < InstanceEnd);
5430
5431 assert(buffer.empty());
5432
5433 // Skip the next N words.
5434 auto skip = [&](unsigned numWords) {
5435 assert(numWords > 0);
5436
5437 // Try to merge into the previous byte. Since scans happen second, we
5438 // can't do this if it includes a scan.
5439 if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5440 unsigned lastSkip = buffer.back() >> SkipShift;
5441 if (lastSkip < MaxNibble) {
5442 unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5443 numWords -= claimed;
5444 lastSkip += claimed;
5445 buffer.back() = (lastSkip << SkipShift);
5446 }
5447 }
5448
5449 while (numWords >= MaxNibble) {
5450 buffer.push_back(MaxNibble << SkipShift);
5451 numWords -= MaxNibble;
5452 }
5453 if (numWords) {
5454 buffer.push_back(numWords << SkipShift);
5455 }
5456 };
5457
5458 // Scan the next N words.
5459 auto scan = [&](unsigned numWords) {
5460 assert(numWords > 0);
5461
5462 // Try to merge into the previous byte. Since scans happen second, we can
5463 // do this even if it includes a skip.
5464 if (!buffer.empty()) {
5465 unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5466 if (lastScan < MaxNibble) {
5467 unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5468 numWords -= claimed;
5469 lastScan += claimed;
5470 buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5471 }
5472 }
5473
5474 while (numWords >= MaxNibble) {
5475 buffer.push_back(MaxNibble << ScanShift);
5476 numWords -= MaxNibble;
5477 }
5478 if (numWords) {
5479 buffer.push_back(numWords << ScanShift);
5480 }
5481 };
5482
5483 // One past the end of the last scan.
5484 unsigned endOfLastScanInWords = 0;
5485 const CharUnits WordSize = CGM.getPointerSize();
5486
5487 // Consider all the scan requests.
5488 for (auto &request : IvarsInfo) {
5489 CharUnits beginOfScan = request.Offset - InstanceBegin;
5490
5491 // Ignore scan requests that don't start at an even multiple of the
5492 // word size. We can't encode them.
5493 if ((beginOfScan % WordSize) != 0) continue;
5494
5495 // Ignore scan requests that start before the instance start.
5496 // This assumes that scans never span that boundary. The boundary
5497 // isn't the true start of the ivars, because in the fragile-ARC case
5498 // it's rounded up to word alignment, but the test above should leave
5499 // us ignoring that possibility.
5500 if (beginOfScan.isNegative()) {
5501 assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
5502 continue;
5503 }
5504
5505 unsigned beginOfScanInWords = beginOfScan / WordSize;
5506 unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5507
5508 // If the scan starts some number of words after the last one ended,
5509 // skip forward.
5510 if (beginOfScanInWords > endOfLastScanInWords) {
5511 skip(beginOfScanInWords - endOfLastScanInWords);
5512
5513 // Otherwise, start scanning where the last left off.
5514 } else {
5515 beginOfScanInWords = endOfLastScanInWords;
5516
5517 // If that leaves us with nothing to scan, ignore this request.
5518 if (beginOfScanInWords >= endOfScanInWords) continue;
5519 }
5520
5521 // Scan to the end of the request.
5522 assert(beginOfScanInWords < endOfScanInWords);
5523 scan(endOfScanInWords - beginOfScanInWords);
5524 endOfLastScanInWords = endOfScanInWords;
5525 }
5526
5527 if (buffer.empty())
5528 return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5529
5530 // For GC layouts, emit a skip to the end of the allocation so that we
5531 // have precise information about the entire thing. This isn't useful
5532 // or necessary for the ARC-style layout strings.
5533 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5534 unsigned lastOffsetInWords =
5535 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5536 if (lastOffsetInWords > endOfLastScanInWords) {
5537 skip(lastOffsetInWords - endOfLastScanInWords);
5538 }
5539 }
5540
5541 // Null terminate the string.
5542 buffer.push_back(0);
5543
5544 auto *Entry = CGObjC.CreateCStringLiteral(
5545 reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5546 return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5547}
5548
5549/// BuildIvarLayout - Builds ivar layout bitmap for the class
5550/// implementation for the __strong or __weak case.
5551/// The layout map displays which words in ivar list must be skipped
5552/// and which must be scanned by GC (see below). String is built of bytes.
5553/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5554/// of words to skip and right nibble is count of words to scan. So, each
5555/// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5556/// represented by a 0x00 byte which also ends the string.
5557/// 1. when ForStrongLayout is true, following ivars are scanned:
5558/// - id, Class
5559/// - object *
5560/// - __strong anything
5561///
5562/// 2. When ForStrongLayout is false, following ivars are scanned:
5563/// - __weak anything
5564///
5565llvm::Constant *
5566CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5567 CharUnits beginOffset, CharUnits endOffset,
5568 bool ForStrongLayout, bool HasMRCWeakIvars) {
5569 // If this is MRC, and we're either building a strong layout or there
5570 // are no weak ivars, bail out early.
5571 llvm::Type *PtrTy = CGM.Int8PtrTy;
5572 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5573 !CGM.getLangOpts().ObjCAutoRefCount &&
5574 (ForStrongLayout || !HasMRCWeakIvars))
5575 return llvm::Constant::getNullValue(PtrTy);
5576
5577 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5578 SmallVector<const ObjCIvarDecl*, 32> ivars;
5579
5580 // GC layout strings include the complete object layout, possibly
5581 // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5582 // up.
5583 //
5584 // ARC layout strings only include the class's ivars. In non-fragile
5585 // runtimes, that means starting at InstanceStart, rounded up to word
5586 // alignment. In fragile runtimes, there's no InstanceStart, so it means
5587 // starting at the offset of the first ivar, rounded up to word alignment.
5588 //
5589 // MRC weak layout strings follow the ARC style.
5590 CharUnits baseOffset;
5591 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5592 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5593 IVD; IVD = IVD->getNextIvar())
5594 ivars.push_back(IVD);
5595
5596 if (isNonFragileABI()) {
5597 baseOffset = beginOffset; // InstanceStart
5598 } else if (!ivars.empty()) {
5599 baseOffset =
5600 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5601 } else {
5602 baseOffset = CharUnits::Zero();
5603 }
5604
5605 baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5606 }
5607 else {
5608 CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5609
5610 baseOffset = CharUnits::Zero();
5611 }
5612
5613 if (ivars.empty())
5614 return llvm::Constant::getNullValue(PtrTy);
5615
5616 IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5617
5618 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5619 [&](const ObjCIvarDecl *ivar) -> CharUnits {
5620 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5621 });
5622
5623 if (!builder.hasBitmapData())
5624 return llvm::Constant::getNullValue(PtrTy);
5625
5626 llvm::SmallVector<unsigned char, 4> buffer;
5627 llvm::Constant *C = builder.buildBitmap(*this, buffer);
5628
5629 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5630 printf("\n%s ivar layout for class '%s': ",
5631 ForStrongLayout ? "strong" : "weak",
5632 OMD->getClassInterface()->getName().str().c_str());
5633 builder.dump(buffer);
5634 }
5635 return C;
5636}
5637
5638llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5639 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5640 // FIXME: Avoid std::string in "Sel.getAsString()"
5641 if (!Entry)
5642 Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5643 return getConstantGEP(VMContext, Entry, 0, 0);
5644}
5645
5646// FIXME: Merge into a single cstring creation function.
5647llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5648 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5649}
5650
5651llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5652 std::string TypeStr;
5653 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5654
5655 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5656 if (!Entry)
5657 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5658 return getConstantGEP(VMContext, Entry, 0, 0);
5659}
5660
5661llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5662 bool Extended) {
5663 std::string TypeStr =
5664 CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5665
5666 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5667 if (!Entry)
5668 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5669 return getConstantGEP(VMContext, Entry, 0, 0);
5670}
5671
5672// FIXME: Merge into a single cstring creation function.
5673llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5674 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5675 if (!Entry)
5676 Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5677 return getConstantGEP(VMContext, Entry, 0, 0);
5678}
5679
5680// FIXME: Merge into a single cstring creation function.
5681// FIXME: This Decl should be more precise.
5682llvm::Constant *
5683CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5684 const Decl *Container) {
5685 std::string TypeStr =
5686 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5687 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5688}
5689
5690void CGObjCMac::FinishModule() {
5691 EmitModuleInfo();
5692
5693 // Emit the dummy bodies for any protocols which were referenced but
5694 // never defined.
5695 for (auto &entry : Protocols) {
5696 llvm::GlobalVariable *global = entry.second;
5697 if (global->hasInitializer())
5698 continue;
5699
5700 ConstantInitBuilder builder(CGM);
5701 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5702 values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5703 values.add(GetClassName(entry.first->getName()));
5704 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5705 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5706 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5707 values.finishAndSetAsInitializer(global);
5708 CGM.addCompilerUsedGlobal(global);
5709 }
5710
5711 // Add assembler directives to add lazy undefined symbol references
5712 // for classes which are referenced but not defined. This is
5713 // important for correct linker interaction.
5714 //
5715 // FIXME: It would be nice if we had an LLVM construct for this.
5716 if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5717 CGM.getTriple().isOSBinFormatMachO()) {
5718 SmallString<256> Asm;
5719 Asm += CGM.getModule().getModuleInlineAsm();
5720 if (!Asm.empty() && Asm.back() != '\n')
5721 Asm += '\n';
5722
5723 llvm::raw_svector_ostream OS(Asm);
5724 for (const auto *Sym : DefinedSymbols)
5725 OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5726 << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5727 for (const auto *Sym : LazySymbols)
5728 OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5729 for (const auto &Category : DefinedCategoryNames)
5730 OS << "\t.objc_category_name_" << Category << "=0\n"
5731 << "\t.globl .objc_category_name_" << Category << "\n";
5732
5733 CGM.getModule().setModuleInlineAsm(OS.str());
5734 }
5735}
5736
5737CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5738 : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5739 ObjCEmptyVtableVar(nullptr) {
5740 ObjCABI = 2;
5741}
5742
5743/* *** */
5744
5745ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5746 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5747{
5748 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5749 ASTContext &Ctx = CGM.getContext();
5750 unsigned ProgramAS = CGM.getDataLayout().getProgramAddressSpace();
5751
5752 ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5753 IntTy = CGM.IntTy;
5754 LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5755 Int8PtrTy = CGM.Int8PtrTy;
5756 Int8PtrProgramASTy = llvm::PointerType::get(CGM.Int8Ty, ProgramAS);
5757 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5758
5759 // arm64 targets use "int" ivar offset variables. All others,
5760 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5761 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5762 IvarOffsetVarTy = IntTy;
5763 else
5764 IvarOffsetVarTy = LongTy;
5765
5766 ObjectPtrTy =
5767 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5768 PtrObjectPtrTy =
5769 llvm::PointerType::getUnqual(ObjectPtrTy);
5770 SelectorPtrTy =
5771 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5772
5773 // I'm not sure I like this. The implicit coordination is a bit
5774 // gross. We should solve this in a reasonable fashion because this
5775 // is a pretty common task (match some runtime data structure with
5776 // an LLVM data structure).
5777
5778 // FIXME: This is leaked.
5779 // FIXME: Merge with rewriter code?
5780
5781 // struct _objc_super {
5782 // id self;
5783 // Class cls;
5784 // }
5785 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5786 Ctx.getTranslationUnitDecl(),
5787 SourceLocation(), SourceLocation(),
5788 &Ctx.Idents.get("_objc_super"));
5789 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5790 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5791 false, ICIS_NoInit));
5792 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),