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