Coverage Report

Created: 2022-05-17 06:19

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