Coverage Report

Created: 2021-01-26 06:56

/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.6k
  llvm::FunctionCallee getMessageSendFn() const {
66
    // Add the non-lazy-bind attribute, since objc_msgSend is likely to
67
    // be called a lot.
68
11.6k
    llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
69
11.6k
    return CGM.CreateRuntimeFunction(
70
11.6k
        llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
71
11.6k
        llvm::AttributeList::get(CGM.getLLVMContext(),
72
11.6k
                                 llvm::AttributeList::FunctionIndex,
73
11.6k
                                 llvm::Attribute::NonLazyBind));
74
11.6k
  }
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
473
  llvm::FunctionCallee getMessageSendSuperFn2() const {
133
473
    llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
134
473
    return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
135
473
                                                             params, true),
136
473
                                     "objc_msgSendSuper2");
137
473
  }
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
103
  llvm::FunctionCallee getGetPropertyFn() {
236
103
    CodeGen::CodeGenTypes &Types = CGM.getTypes();
237
103
    ASTContext &Ctx = CGM.getContext();
238
    // id objc_getProperty (id, SEL, ptrdiff_t, bool)
239
103
    CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
240
103
    CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
241
103
    CanQualType Params[] = {
242
103
        IdType, SelType,
243
103
        Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy};
244
103
    llvm::FunctionType *FTy =
245
103
        Types.GetFunctionType(
246
103
          Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
247
103
    return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
248
103
  }
249
250
63
  llvm::FunctionCallee getSetPropertyFn() {
251
63
    CodeGen::CodeGenTypes &Types = CGM.getTypes();
252
63
    ASTContext &Ctx = CGM.getContext();
253
    // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
254
63
    CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
255
63
    CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
256
63
    CanQualType Params[] = {
257
63
        IdType,
258
63
        SelType,
259
63
        Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(),
260
63
        IdType,
261
63
        Ctx.BoolTy,
262
63
        Ctx.BoolTy};
263
63
    llvm::FunctionType *FTy =
264
63
        Types.GetFunctionType(
265
63
          Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
266
63
    return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
267
63
  }
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
72
  llvm::FunctionCallee getEnumerationMutationFn() {
339
72
    CodeGen::CodeGenTypes &Types = CGM.getTypes();
340
72
    ASTContext &Ctx = CGM.getContext();
341
    // void objc_enumerationMutation (id)
342
72
    SmallVector<CanQualType,1> Params;
343
72
    Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
344
72
    llvm::FunctionType *FTy =
345
72
        Types.GetFunctionType(
346
72
          Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
347
72
    return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
348
72
  }
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
149
  llvm::FunctionCallee getExceptionRethrowFn() {
438
    // void objc_exception_rethrow(void)
439
149
    llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
440
149
    return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
441
149
  }
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
188
    return IsSuper ? 
getMessageSendSuperFn()21
: getMessageSendFn();
463
209
  }
464
465
11.9k
  llvm::FunctionCallee getSendFn2(bool IsSuper) const {
466
11.4k
    return IsSuper ? 
getMessageSendSuperFn2()473
: getMessageSendFn();
467
11.9k
  }
468
469
4
  llvm::FunctionCallee getSendStretFn(bool IsSuper) const {
470
2
    return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
471
4
  }
472
473
15
  llvm::FunctionCallee getSendStretFn2(bool IsSuper) const {
474
13
    return IsSuper ? 
getMessageSendSuperStretFn2()2
: getMessageSendStretFn();
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
136
  llvm::FunctionCallee getObjCEndCatchFn() {
716
136
    return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
717
136
                                     "objc_end_catch");
718
136
  }
719
720
136
  llvm::FunctionCallee getObjCBeginCatchFn() {
721
136
    llvm::Type *params[] = { Int8PtrTy };
722
136
    return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
723
136
                                                             params, false),
724
136
                                     "objc_begin_catch");
725
136
  }
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.19k
    : opcode(Opcode), block_var_bytepos(BytePos),  block_var_size(Size) {}
838
839
    // Allow sorting based on byte pos.
840
937
    bool operator<(const RUN_SKIP &b) const {
841
937
      return block_var_bytepos < b.block_var_bytepos;
842
937
    }
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.08k
                                        CharUnits endOffset) {
973
1.08k
    return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
974
1.08k
  }
975
976
  llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
977
                                      CharUnits beginOffset,
978
                                      CharUnits endOffset,
979
1.08k
                                      bool hasMRCWeakIvars) {
980
1.08k
    return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
981
1.08k
  }
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
13.4k
      : 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
0
    }
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
84
      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
7
      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
77
      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.59k
  StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1545
1546
4.55k
  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.20k
  Selector GetNullarySelector(const char* name) const {
1554
1.20k
    IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1555
1.20k
    return CGM.getContext().Selectors.getSelector(0, &II);
1556
1.20k
  }
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.37k
                                   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.37k
    if (const ObjCMethodDecl *MD =
1584
1.23k
          dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1585
1.23k
      if (MD->isInstanceMethod() && !MD->isDirectMethod())
1586
1.22k
        if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1587
1.22k
          return IV->getContainingInterface()->isSuperClassOf(ID);
1588
148
    return false;
1589
148
  }
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.14k
&&
1597
2.46k
           ID->getSuperClass()->getName() == "NSObject";
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
12.0k
    { 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
103
  llvm::FunctionCallee GetPropertyGetFunction() override {
1649
103
    return ObjCTypes.getGetPropertyFn();
1650
103
  }
1651
63
  llvm::FunctionCallee GetPropertySetFunction() override {
1652
63
    return ObjCTypes.getSetPropertyFn();
1653
63
  }
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
67
  llvm::FunctionCallee EnumerationMutationFunction() override {
1677
67
    return ObjCTypes.getEnumerationMutationFn();
1678
67
  }
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
12.2k
  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
12.2k
                  const ObjCMethodDecl *Method) {
1740
    // If we never had to do a null-check, just use the raw result.
1741
12.2k
    if (!NullBB) 
return result12.2k
;
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
    // Release any consumed arguments we've got.
1758
35
    if (Method) {
1759
35
      CallArgList::const_iterator I = CallArgs.begin();
1760
35
      for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1761
61
           e = Method->param_end(); i != e; 
++i, ++I26
) {
1762
26
        const ParmVarDecl *ParamDecl = (*i);
1763
26
        if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1764
10
          RValue RV = I->getRValue(CGF);
1765
10
          assert(RV.isScalar() &&
1766
10
                 "NullReturnState::complete - arg not on object");
1767
10
          CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1768
16
        } else {
1769
16
          QualType QT = ParamDecl->getType();
1770
16
          auto *RT = QT->getAs<RecordType>();
1771
16
          if (RT && RT->getDecl()->isParamDestroyedInCallee()) {
1772
16
            RValue RV = I->getRValue(CGF);
1773
16
            QualType::DestructionKind DtorKind = QT.isDestructedType();
1774
16
            switch (DtorKind) {
1775
8
            case QualType::DK_cxx_destructor:
1776
8
              CGF.destroyCXXObject(CGF, RV.getAggregateAddress(), QT);
1777
8
              break;
1778
8
            case QualType::DK_nontrivial_c_struct:
1779
8
              CGF.destroyNonTrivialCStruct(CGF, RV.getAggregateAddress(), QT);
1780
8
              break;
1781
0
            default:
1782
0
              llvm_unreachable("unexpected dtor kind");
1783
0
              break;
1784
16
            }
1785
16
          }
1786
16
        }
1787
26
      }
1788
35
    }
1789
1790
    // The phi code below assumes that we haven't needed any control flow yet.
1791
35
    assert(CGF.Builder.GetInsertBlock() == NullBB);
1792
1793
    // If we've got a void return, just jump to the continuation block.
1794
35
    if (result.isScalar() && 
resultType->isVoidType()23
) {
1795
      // No jumps required if the message-send was noreturn.
1796
19
      if (contBB) CGF.EmitBlock(contBB);
1797
19
      return result;
1798
19
    }
1799
1800
    // If we've got a scalar return, build a phi.
1801
16
    if (result.isScalar()) {
1802
      // Derive the null-initialization value.
1803
4
      llvm::Value *null =
1804
4
          CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(resultType), resultType);
1805
1806
      // If no join is necessary, just flow out.
1807
4
      if (!contBB) 
return RValue::get(null)0
;
1808
1809
      // Otherwise, build a phi.
1810
4
      CGF.EmitBlock(contBB);
1811
4
      llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1812
4
      phi->addIncoming(result.getScalarVal(), callBB);
1813
4
      phi->addIncoming(null, NullBB);
1814
4
      return RValue::get(phi);
1815
4
    }
1816
1817
    // If we've got an aggregate return, null the buffer out.
1818
    // FIXME: maybe we should be doing things differently for all the
1819
    // cases where the ABI has us returning (1) non-agg values in
1820
    // memory or (2) agg values in registers.
1821
12
    if (result.isAggregate()) {
1822
9
      assert(result.isAggregate() && "null init of non-aggregate result?");
1823
9
      if (!returnSlot.isUnused())
1824
7
        CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1825
9
      if (contBB) CGF.EmitBlock(contBB);
1826
9
      return result;
1827
9
    }
1828
1829
    // Complex types.
1830
3
    CGF.EmitBlock(contBB);
1831
3
    CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1832
1833
    // Find the scalar type and its zero value.
1834
3
    llvm::Type *scalarTy = callResult.first->getType();
1835
3
    llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1836
1837
    // Build phis for both coordinates.
1838
3
    llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1839
3
    real->addIncoming(callResult.first, callBB);
1840
3
    real->addIncoming(scalarZero, NullBB);
1841
3
    llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1842
3
    imag->addIncoming(callResult.second, callBB);
1843
3
    imag->addIncoming(scalarZero, NullBB);
1844
3
    return RValue::getComplex(real, imag);
1845
3
  }
1846
};
1847
1848
} // end anonymous namespace
1849
1850
/* *** Helper Functions *** */
1851
1852
/// getConstantGEP() - Help routine to construct simple GEPs.
1853
static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1854
                                      llvm::GlobalVariable *C, unsigned idx0,
1855
17.4k
                                      unsigned idx1) {
1856
17.4k
  llvm::Value *Idxs[] = {
1857
17.4k
    llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1858
17.4k
    llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1859
17.4k
  };
1860
17.4k
  return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1861
17.4k
}
1862
1863
/// hasObjCExceptionAttribute - Return true if this class or any super
1864
/// class has the __objc_exception__ attribute.
1865
static bool hasObjCExceptionAttribute(ASTContext &Context,
1866
1.92k
                                      const ObjCInterfaceDecl *OID) {
1867
1.92k
  if (OID->hasAttr<ObjCExceptionAttr>())
1868
64
    return true;
1869
1.86k
  if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1870
838
    return hasObjCExceptionAttribute(Context, Super);
1871
1.02k
  return false;
1872
1.02k
}
1873
1874
static llvm::GlobalValue::LinkageTypes
1875
12.3k
getLinkageTypeForObjCMetadata(CodeGenModule &CGM, StringRef Section) {
1876
12.3k
  if (CGM.getTriple().isOSBinFormatMachO() &&
1877
12.0k
      (Section.empty() || 
Section.startswith("__DATA")12.0k
))
1878
11.4k
    return llvm::GlobalValue::InternalLinkage;
1879
937
  return llvm::GlobalValue::PrivateLinkage;
1880
937
}
1881
1882
/// A helper function to create an internal or private global variable.
1883
static llvm::GlobalVariable *
1884
finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder,
1885
3.84k
                     const llvm::Twine &Name, CodeGenModule &CGM) {
1886
3.84k
  std::string SectionName;
1887
3.84k
  if (CGM.getTriple().isOSBinFormatMachO())
1888
3.76k
    SectionName = "__DATA, __objc_const";
1889
3.84k
  auto *GV = Builder.finishAndCreateGlobal(
1890
3.84k
      Name, CGM.getPointerAlign(), /*constant*/ false,
1891
3.84k
      getLinkageTypeForObjCMetadata(CGM, SectionName));
1892
3.84k
  GV->setSection(SectionName);
1893
3.84k
  return GV;
1894
3.84k
}
1895
1896
/* *** CGObjCMac Public Interface *** */
1897
1898
CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1899
167
                                                    ObjCTypes(cgm) {
1900
167
  ObjCABI = 1;
1901
167
  EmitImageInfo();
1902
167
}
1903
1904
/// GetClass - Return a reference to the class for the given interface
1905
/// decl.
1906
llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1907
50
                                 const ObjCInterfaceDecl *ID) {
1908
50
  return EmitClassRef(CGF, ID);
1909
50
}
1910
1911
/// GetSelector - Return the pointer to the unique'd string for this selector.
1912
220
llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1913
220
  return EmitSelector(CGF, Sel);
1914
220
}
1915
1
Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1916
1
  return EmitSelectorAddr(Sel);
1917
1
}
1918
llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1919
0
                                    *Method) {
1920
0
  return EmitSelector(CGF, Method->getSelector());
1921
0
}
1922
1923
3
llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1924
3
  if (T->isObjCIdType() ||
1925
2
      T->isObjCQualifiedIdType()) {
1926
1
    return CGM.GetAddrOfRTTIDescriptor(
1927
1
              CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1928
1
  }
1929
2
  if (T->isObjCClassType() ||
1930
1
      T->isObjCQualifiedClassType()) {
1931
1
    return CGM.GetAddrOfRTTIDescriptor(
1932
1
             CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1933
1
  }
1934
1
  if (T->isObjCObjectPointerType())
1935
1
    return CGM.GetAddrOfRTTIDescriptor(T,  /*ForEH=*/true);
1936
1937
0
  llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1938
0
}
1939
1940
/// Generate a constant CFString object.
1941
/*
1942
  struct __builtin_CFString {
1943
  const int *isa; // point to __CFConstantStringClassReference
1944
  int flags;
1945
  const char *str;
1946
  long length;
1947
  };
1948
*/
1949
1950
/// or Generate a constant NSString object.
1951
/*
1952
   struct __builtin_NSString {
1953
     const int *isa; // point to __NSConstantStringClassReference
1954
     const char *str;
1955
     unsigned int length;
1956
   };
1957
*/
1958
1959
ConstantAddress
1960
5.24k
CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1961
5.24k
  return (!CGM.getLangOpts().NoConstantCFStrings
1962
5.24k
            ? CGM.GetAddrOfConstantCFString(SL)
1963
9
            : GenerateConstantNSString(SL));
1964
5.24k
}
1965
1966
static llvm::StringMapEntry<llvm::GlobalVariable *> &
1967
GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1968
9
                       const StringLiteral *Literal, unsigned &StringLength) {
1969
9
  StringRef String = Literal->getString();
1970
9
  StringLength = String.size();
1971
9
  return *Map.insert(std::make_pair(String, nullptr)).first;
1972
9
}
1973
1974
3
llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1975
3
  if (llvm::Value *V = ConstantStringClassRef)
1976
1
    return cast<llvm::Constant>(V);
1977
1978
2
  auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1979
2
  std::string str =
1980
1
    StringClass.empty() ? "_NSConstantStringClassReference"
1981
1
                        : "_" + StringClass + "ClassReference";
1982
1983
2
  llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1984
2
  auto GV = CGM.CreateRuntimeVariable(PTy, str);
1985
2
  auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1986
2
  ConstantStringClassRef = V;
1987
2
  return V;
1988
2
}
1989
1990
4
llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1991
4
  if (llvm::Value *V = ConstantStringClassRef)
1992
1
    return cast<llvm::Constant>(V);
1993
1994
3
  auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1995
3
  std::string str =
1996
1
    StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1997
2
                        : "OBJC_CLASS_$_" + StringClass;
1998
3
  llvm::Constant *GV = GetClassGlobal(str, NotForDefinition);
1999
2000
  // Make sure the result is of the correct type.
2001
3
  auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
2002
2003
3
  ConstantStringClassRef = V;
2004
3
  return V;
2005
3
}
2006
2007
ConstantAddress
2008
9
CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
2009
9
  unsigned StringLength = 0;
2010
9
  llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2011
9
    GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
2012
2013
9
  if (auto *C = Entry.second)
2014
2
    return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
2015
2016
  // If we don't already have it, get _NSConstantStringClassReference.
2017
7
  llvm::Constant *Class = getNSConstantStringClassRef();
2018
2019
  // If we don't already have it, construct the type for a constant NSString.
2020
7
  if (!NSConstantStringType) {
2021
5
    NSConstantStringType =
2022
5
      llvm::StructType::create({
2023
5
        CGM.Int32Ty->getPointerTo(),
2024
5
        CGM.Int8PtrTy,
2025
5
        CGM.IntTy
2026
5
      }, "struct.__builtin_NSString");
2027
5
  }
2028
2029
7
  ConstantInitBuilder Builder(CGM);
2030
7
  auto Fields = Builder.beginStruct(NSConstantStringType);
2031
2032
  // Class pointer.
2033
7
  Fields.add(Class);
2034
2035
  // String pointer.
2036
7
  llvm::Constant *C =
2037
7
    llvm::ConstantDataArray::getString(VMContext, Entry.first());
2038
2039
7
  llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
2040
7
  bool isConstant = !CGM.getLangOpts().WritableStrings;
2041
2042
7
  auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
2043
7
                                      Linkage, C, ".str");
2044
7
  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2045
  // Don't enforce the target's minimum global alignment, since the only use
2046
  // of the string is via this class initializer.
2047
7
  GV->setAlignment(llvm::Align(1));
2048
7
  Fields.addBitCast(GV, CGM.Int8PtrTy);
2049
2050
  // String length.
2051
7
  Fields.addInt(CGM.IntTy, StringLength);
2052
2053
  // The struct.
2054
7
  CharUnits Alignment = CGM.getPointerAlign();
2055
7
  GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
2056
7
                                    /*constant*/ true,
2057
7
                                    llvm::GlobalVariable::PrivateLinkage);
2058
7
  const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
2059
7
  const char *NSStringNonFragileABISection =
2060
7
      "__DATA,__objc_stringobj,regular,no_dead_strip";
2061
  // FIXME. Fix section.
2062
7
  GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
2063
4
                     ? NSStringNonFragileABISection
2064
3
                     : NSStringSection);
2065
7
  Entry.second = GV;
2066
2067
7
  return ConstantAddress(GV, Alignment);
2068
7
}
2069
2070
enum {
2071
  kCFTaggedObjectID_Integer = (1 << 1) + 1
2072
};
2073
2074
/// Generates a message send where the super is the receiver.  This is
2075
/// a message send to self with special delivery semantics indicating
2076
/// which class's method should be called.
2077
CodeGen::RValue
2078
CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
2079
                                    ReturnValueSlot Return,
2080
                                    QualType ResultType,
2081
                                    Selector Sel,
2082
                                    const ObjCInterfaceDecl *Class,
2083
                                    bool isCategoryImpl,
2084
                                    llvm::Value *Receiver,
2085
                                    bool IsClassMessage,
2086
                                    const CodeGen::CallArgList &CallArgs,
2087
23
                                    const ObjCMethodDecl *Method) {
2088
  // Create and init a super structure; this is a (receiver, class)
2089
  // pair we will pass to objc_msgSendSuper.
2090
23
  Address ObjCSuper =
2091
23
    CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
2092
23
                         "objc_super");
2093
23
  llvm::Value *ReceiverAsObject =
2094
23
    CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2095
23
  CGF.Builder.CreateStore(ReceiverAsObject,
2096
23
                          CGF.Builder.CreateStructGEP(ObjCSuper, 0));
2097
2098
  // If this is a class message the metaclass is passed as the target.
2099
23
  llvm::Value *Target;
2100
23
  if (IsClassMessage) {
2101
7
    if (isCategoryImpl) {
2102
      // Message sent to 'super' in a class method defined in a category
2103
      // implementation requires an odd treatment.
2104
      // If we are in a class method, we must retrieve the
2105
      // _metaclass_ for the current class, pointed at by
2106
      // the class's "isa" pointer.  The following assumes that
2107
      // isa" is the first ivar in a class (which it must be).
2108
0
      Target = EmitClassRef(CGF, Class->getSuperClass());
2109
0
      Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2110
0
      Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
2111
7
    } else {
2112
7
      llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2113
7
      llvm::Value *SuperPtr =
2114
7
          CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2115
7
      llvm::Value *Super =
2116
7
        CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
2117
7
      Target = Super;
2118
7
    }
2119
16
  } else if (isCategoryImpl)
2120
0
    Target = EmitClassRef(CGF, Class->getSuperClass());
2121
16
  else {
2122
16
    llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2123
16
    ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2124
16
    Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
2125
16
  }
2126
  // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2127
  // ObjCTypes types.
2128
23
  llvm::Type *ClassTy =
2129
23
    CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
2130
23
  Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2131
23
  CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
2132
23
  return EmitMessageSend(CGF, Return, ResultType, Sel, ObjCSuper.getPointer(),
2133
23
                         ObjCTypes.SuperPtrCTy, true, CallArgs, Method, Class,
2134
23
                         ObjCTypes);
2135
23
}
2136
2137
/// Generate code for a message send expression.
2138
CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2139
                                               ReturnValueSlot Return,
2140
                                               QualType ResultType,
2141
                                               Selector Sel,
2142
                                               llvm::Value *Receiver,
2143
                                               const CallArgList &CallArgs,
2144
                                               const ObjCInterfaceDecl *Class,
2145
195
                                               const ObjCMethodDecl *Method) {
2146
195
  return EmitMessageSend(CGF, Return, ResultType, Sel, Receiver,
2147
195
                         CGF.getContext().getObjCIdType(), false, CallArgs,
2148
195
                         Method, Class, ObjCTypes);
2149
195
}
2150
2151
4.13k
static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
2152
9.13k
  do {
2153
9.13k
    if (ID->isWeakImported())
2154
5
      return true;
2155
9.12k
  } while ((ID = ID->getSuperClass()));
2156
2157
4.12k
  return false;
2158
4.13k
}
2159
2160
CodeGen::RValue
2161
CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2162
                                 ReturnValueSlot Return,
2163
                                 QualType ResultType,
2164
                                 Selector Sel,
2165
                                 llvm::Value *Arg0,
2166
                                 QualType Arg0Ty,
2167
                                 bool IsSuper,
2168
                                 const CallArgList &CallArgs,
2169
                                 const ObjCMethodDecl *Method,
2170
                                 const ObjCInterfaceDecl *ClassReceiver,
2171
12.2k
                                 const ObjCCommonTypesHelper &ObjCTypes) {
2172
12.2k
  CodeGenTypes &Types = CGM.getTypes();
2173
12.2k
  auto selTy = CGF.getContext().getObjCSelType();
2174
12.2k
  llvm::Value *SelValue;
2175
2176
12.2k
  if (Method && 
Method->isDirectMethod()11.4k
) {
2177
    // Direct methods will synthesize the proper `_cmd` internally,
2178
    // so just don't bother with setting the `_cmd` argument.
2179
67
    assert(!IsSuper);
2180
67
    SelValue = llvm::UndefValue::get(Types.ConvertType(selTy));
2181
12.1k
  } else {
2182
12.1k
    SelValue = GetSelector(CGF, Sel);
2183
12.1k
  }
2184
2185
12.2k
  CallArgList ActualArgs;
2186
12.2k
  if (!IsSuper)
2187
11.7k
    Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2188
12.2k
  ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2189
12.2k
  ActualArgs.add(RValue::get(SelValue), selTy);
2190
12.2k
  ActualArgs.addFrom(CallArgs);
2191
2192
  // If we're calling a method, use the formal signature.
2193
12.2k
  MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2194
2195
12.2k
  if (Method)
2196
12.2k
    assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
2197
12.2k
               CGM.getContext().getCanonicalType(ResultType) &&
2198
12.2k
           "Result type mismatch!");
2199
2200
12.2k
  bool ReceiverCanBeNull = true;
2201
2202
  // Super dispatch assumes that self is non-null; even the messenger
2203
  // doesn't have a null check internally.
2204
12.2k
  if (IsSuper) {
2205
498
    ReceiverCanBeNull = false;
2206
2207
  // If this is a direct dispatch of a class method, check whether the class,
2208
  // or anything in its hierarchy, was weak-linked.
2209
11.7k
  } else if (ClassReceiver && 
Method4.16k
&&
Method->isClassMethod()4.15k
) {
2210
4.13k
    ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
2211
2212
  // If we're emitting a method, and self is const (meaning just ARC, for now),
2213
  // and the receiver is a load of self, then self is a valid object.
2214
7.62k
  } else if (auto CurMethod =
2215
402
               dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
2216
402
    auto Self = CurMethod->getSelfDecl();
2217
402
    if (Self->getType().isConstQualified()) {
2218
29
      if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
2219
23
        llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
2220
23
        if (SelfAddr == LI->getPointerOperand()) {
2221
14
          ReceiverCanBeNull = false;
2222
14
        }
2223
23
      }
2224
29
    }
2225
402
  }
2226
2227
12.2k
  bool RequiresNullCheck = false;
2228
2229
12.2k
  llvm::FunctionCallee Fn = nullptr;
2230
12.2k
  if (Method && 
Method->isDirectMethod()11.4k
) {
2231
67
    Fn = GenerateDirectMethod(Method, Method->getClassInterface());
2232
12.1k
  } else if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2233
19
    if (ReceiverCanBeNull) 
RequiresNullCheck = true12
;
2234
15
    Fn = (ObjCABI == 2) ?  ObjCTypes.getSendStretFn2(IsSuper)
2235
4
      : ObjCTypes.getSendStretFn(IsSuper);
2236
12.1k
  } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2237
2
    Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2238
4
      : ObjCTypes.getSendFpretFn(IsSuper);
2239
12.1k
  } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2240
0
    Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2241
1
      : ObjCTypes.getSendFp2retFn(IsSuper);
2242
12.1k
  } else {
2243
    // arm64 uses objc_msgSend for stret methods and yet null receiver check
2244
    // must be made for it.
2245
12.1k
    if (ReceiverCanBeNull && 
CGM.ReturnTypeUsesSRet(MSI.CallInfo)7.52k
)
2246
6
      RequiresNullCheck = true;
2247
11.9k
    Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2248
209
      : ObjCTypes.getSendFn(IsSuper);
2249
12.1k
  }
2250
2251
  // Cast function to proper signature
2252
12.2k
  llvm::Constant *BitcastFn = cast<llvm::Constant>(
2253
12.2k
      CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType));
2254
2255
  // We don't need to emit a null check to zero out an indirect result if the
2256
  // result is ignored.
2257
12.2k
  if (Return.isUnused())
2258
15
    RequiresNullCheck = false;
2259
2260
  // Emit a null-check if there's a consumed argument other than the receiver.
2261
12.2k
  if (!RequiresNullCheck && 
CGM.getLangOpts().ObjCAutoRefCount12.2k
&&
Method325
) {
2262
184
    for (const auto *ParamDecl : Method->parameters()) {
2263
184
      if (ParamDecl->isDestroyedInCallee()) {
2264
24
        RequiresNullCheck = true;
2265
24
        break;
2266
24
      }
2267
184
    }
2268
268
  }
2269
2270
12.2k
  NullReturnState nullReturn;
2271
12.2k
  if (RequiresNullCheck) {
2272
33
    nullReturn.init(CGF, Arg0);
2273
33
  }
2274
2275
12.2k
  llvm::CallBase *CallSite;
2276
12.2k
  CGCallee Callee = CGCallee::forDirect(BitcastFn);
2277
12.2k
  RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2278
12.2k
                               &CallSite);
2279
2280
  // Mark the call as noreturn if the method is marked noreturn and the
2281
  // receiver cannot be null.
2282
12.2k
  if (Method && 
Method->hasAttr<NoReturnAttr>()11.4k
&&
!ReceiverCanBeNull16
) {
2283
8
    CallSite->setDoesNotReturn();
2284
8
  }
2285
2286
12.2k
  return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
2287
12.2k
                             RequiresNullCheck ? 
Method33
: nullptr);
2288
12.2k
}
2289
2290
static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT,
2291
756
                                           bool pointee = false) {
2292
  // Note that GC qualification applies recursively to C pointer types
2293
  // that aren't otherwise decorated.  This is weird, but it's probably
2294
  // an intentional workaround to the unreliable placement of GC qualifiers.
2295
756
  if (FQT.isObjCGCStrong())
2296
50
    return Qualifiers::Strong;
2297
2298
706
  if (FQT.isObjCGCWeak())
2299
48
    return Qualifiers::Weak;
2300
2301
658
  if (auto ownership = FQT.getObjCLifetime()) {
2302
    // Ownership does not apply recursively to C pointer types.
2303
175
    if (pointee) 
return Qualifiers::GCNone0
;
2304
175
    switch (ownership) {
2305
31
    case Qualifiers::OCL_Weak: return Qualifiers::Weak;
2306
128
    case Qualifiers::OCL_Strong: return Qualifiers::Strong;
2307
16
    case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone;
2308
0
    case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
2309
0
    case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
2310
0
    }
2311
0
    llvm_unreachable("bad objc ownership");
2312
0
  }
2313
2314
  // Treat unqualified retainable pointers as strong.
2315
483
  if (FQT->isObjCObjectPointerType() || 
FQT->isBlockPointerType()310
)
2316
175
    return Qualifiers::Strong;
2317
2318
  // Walk into C pointer types, but only in GC.
2319
308
  if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2320
244
    if (const PointerType *PT = FQT->getAs<PointerType>())
2321
75
      return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2322
233
  }
2323
2324
233
  return Qualifiers::GCNone;
2325
233
}
2326
2327
namespace {
2328
  struct IvarInfo {
2329
    CharUnits Offset;
2330
    uint64_t SizeInWords;
2331
    IvarInfo(CharUnits offset, uint64_t sizeInWords)
2332
318
      : Offset(offset), SizeInWords(sizeInWords) {}
2333
2334
    // Allow sorting based on byte pos.
2335
209
    bool operator<(const IvarInfo &other) const {
2336
209
      return Offset < other.Offset;
2337
209
    }
2338
  };
2339
2340
  /// A helper class for building GC layout strings.
2341
  class IvarLayoutBuilder {
2342
    CodeGenModule &CGM;
2343
2344
    /// The start of the layout.  Offsets will be relative to this value,
2345
    /// and entries less than this value will be silently discarded.
2346
    CharUnits InstanceBegin;
2347
2348
    /// The end of the layout.  Offsets will never exceed this value.
2349
    CharUnits InstanceEnd;
2350
2351
    /// Whether we're generating the strong layout or the weak layout.
2352
    bool ForStrongLayout;
2353
2354
    /// Whether the offsets in IvarsInfo might be out-of-order.
2355
    bool IsDisordered = false;
2356
2357
    llvm::SmallVector<IvarInfo, 8> IvarsInfo;
2358
2359
  public:
2360
    IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2361
                      CharUnits instanceEnd, bool forStrongLayout)
2362
      : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2363
284
        ForStrongLayout(forStrongLayout) {
2364
284
    }
2365
2366
    void visitRecord(const RecordType *RT, CharUnits offset);
2367
2368
    template <class Iterator, class GetOffsetFn>
2369
    void visitAggregate(Iterator begin, Iterator end,
2370
                        CharUnits aggrOffset,
2371
                        const GetOffsetFn &getOffset);
2372
2373
    void visitField(const FieldDecl *field, CharUnits offset);
2374
2375
    /// Add the layout of a block implementation.
2376
    void visitBlock(const CGBlockInfo &blockInfo);
2377
2378
    /// Is there any information for an interesting bitmap?
2379
284
    bool hasBitmapData() const { return !IvarsInfo.empty(); }
2380
2381
    llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2382
                                llvm::SmallVectorImpl<unsigned char> &buffer);
2383
2384
22
    static void dump(ArrayRef<unsigned char> buffer) {
2385
22
      const unsigned char *s = buffer.data();
2386
95
      for (unsigned i = 0, e = buffer.size(); i < e; 
i++73
)
2387
73
        if (!(s[i] & 0xf0))
2388
41
          printf("0x0%x%s", s[i], s[i] != 0 ? 
", "19
:
""22
);
2389
32
        else
2390
32
          printf("0x%x%s",  s[i], s[i] != 0 ? ", " : 
""0
);
2391
22
      printf("\n");
2392
22
    }
2393
  };
2394
} // end anonymous namespace
2395
2396
llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2397
33
                                                const CGBlockInfo &blockInfo) {
2398
2399
33
  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2400
33
  if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2401
0
    return nullPtr;
2402
2403
33
  IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2404
33
                            /*for strong layout*/ true);
2405
2406
33
  builder.visitBlock(blockInfo);
2407
2408
33
  if (!builder.hasBitmapData())
2409
0
    return nullPtr;
2410
2411
33
  llvm::SmallVector<unsigned char, 32> buffer;
2412
33
  llvm::Constant *C = builder.buildBitmap(*this, buffer);
2413
33
  if (CGM.getLangOpts().ObjCGCBitmapPrint && 
!buffer.empty()15
) {
2414
15
    printf("\n block variable layout for block: ");
2415
15
    builder.dump(buffer);
2416
15
  }
2417
2418
33
  return C;
2419
33
}
2420
2421
33
void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2422
  // __isa is the first field in block descriptor and must assume by runtime's
2423
  // convention that it is GC'able.
2424
33
  IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2425
2426
33
  const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2427
2428
  // Ignore the optional 'this' capture: C++ objects are not assumed
2429
  // to be GC'ed.
2430
2431
33
  CharUnits lastFieldOffset;
2432
2433
  // Walk the captured variables.
2434
91
  for (const auto &CI : blockDecl->captures()) {
2435
91
    const VarDecl *variable = CI.getVariable();
2436
91
    QualType type = variable->getType();
2437
2438
91
    const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2439
2440
    // Ignore constant captures.
2441
91
    if (capture.isConstant()) 
continue0
;
2442
2443
91
    CharUnits fieldOffset = capture.getOffset();
2444
2445
    // Block fields are not necessarily ordered; if we detect that we're
2446
    // adding them out-of-order, make sure we sort later.
2447
91
    if (fieldOffset < lastFieldOffset)
2448
16
      IsDisordered = true;
2449
91
    lastFieldOffset = fieldOffset;
2450
2451
    // __block variables are passed by their descriptor address.
2452
91
    if (CI.isByRef()) {
2453
29
      IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2454
29
      continue;
2455
29
    }
2456
2457
62
    assert(!type->isArrayType() && "array variable should not be caught");
2458
62
    if (const RecordType *record = type->getAs<RecordType>()) {
2459
7
      visitRecord(record, fieldOffset);
2460
7
      continue;
2461
7
    }
2462
2463
55
    Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
2464
2465
55
    if (GCAttr == Qualifiers::Strong) {
2466
27
      assert(CGM.getContext().getTypeSize(type)
2467
27
                == CGM.getTarget().getPointerWidth(0));
2468
27
      IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2469
27
    }
2470
55
  }
2471
33
}
2472
2473
/// getBlockCaptureLifetime - This routine returns life time of the captured
2474
/// block variable for the purpose of block layout meta-data generation. FQT is
2475
/// the type of the variable captured in the block.
2476
Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2477
1.16k
                                                                  bool ByrefLayout) {
2478
  // If it has an ownership qualifier, we're done.
2479
1.16k
  if (auto lifetime = FQT.getObjCLifetime())
2480
720
    return lifetime;
2481
2482
  // If it doesn't, and this is ARC, it has no ownership.
2483
447
  if (CGM.getLangOpts().ObjCAutoRefCount)
2484
276
    return Qualifiers::OCL_None;
2485
2486
  // In MRC, retainable pointers are owned by non-__block variables.
2487
171
  if (FQT->isObjCObjectPointerType() || 
FQT->isBlockPointerType()53
)
2488
124
    return ByrefLayout ? 
Qualifiers::OCL_ExplicitNone2
:
Qualifiers::OCL_Strong122
;
2489
2490
47
  return Qualifiers::OCL_None;
2491
47
}
2492
2493
void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2494
                                             Qualifiers::ObjCLifetime LifeTime,
2495
                                             CharUnits FieldOffset,
2496
1.16k
                                             CharUnits FieldSize) {
2497
  // __block variables are passed by their descriptor address.
2498
1.16k
  if (IsByref)
2499
236
    RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2500
236
                                        FieldSize));
2501
933
  else if (LifeTime == Qualifiers::OCL_Strong)
2502
367
    RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2503
367
                                        FieldSize));
2504
566
  else if (LifeTime == Qualifiers::OCL_Weak)
2505
298
    RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2506
298
                                        FieldSize));
2507
268
  else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2508
47
    RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2509
47
                                        FieldSize));
2510
221
  else
2511
221
    RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2512
221
                                        FieldOffset,
2513
221
                                        FieldSize));
2514
1.16k
}
2515
2516
void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2517
                                          const RecordDecl *RD,
2518
                                          ArrayRef<const FieldDecl*> RecFields,
2519
                                          CharUnits BytePos, bool &HasUnion,
2520
151
                                          bool ByrefLayout) {
2521
151
  bool IsUnion = (RD && RD->isUnion());
2522
151
  CharUnits MaxUnionSize = CharUnits::Zero();
2523
151
  const FieldDecl *MaxField = nullptr;
2524
151
  const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2525
151
  CharUnits MaxFieldOffset = CharUnits::Zero();
2526
151
  CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2527
2528
151
  if (RecFields.empty())
2529
24
    return;
2530
127
  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2531
2532
504
  for (unsigned i = 0, e = RecFields.size(); i != e; 
++i377
) {
2533
377
    const FieldDecl *Field = RecFields[i];
2534
    // Note that 'i' here is actually the field index inside RD of Field,
2535
    // although this dependency is hidden.
2536
377
    const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2537
377
    CharUnits FieldOffset =
2538
377
      CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2539
2540
    // Skip over unnamed or bitfields
2541
377
    if (!Field->getIdentifier() || 
Field->isBitField()355
) {
2542
190
      LastFieldBitfieldOrUnnamed = Field;
2543
190
      LastBitfieldOrUnnamedOffset = FieldOffset;
2544
190
      continue;
2545
190
    }
2546
2547
187
    LastFieldBitfieldOrUnnamed = nullptr;
2548
187
    QualType FQT = Field->getType();
2549
187
    if (FQT->isRecordType() || 
FQT->isUnionType()163
) {
2550
24
      if (FQT->isUnionType())
2551
4
        HasUnion = true;
2552
2553
24
      BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2554
24
                                  BytePos + FieldOffset, HasUnion);
2555
24
      continue;
2556
24
    }
2557
2558
163
    if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2559
27
      auto *CArray = cast<ConstantArrayType>(Array);
2560
27
      uint64_t ElCount = CArray->getSize().getZExtValue();
2561
27
      assert(CArray && "only array with known element size is supported");
2562
27
      FQT = CArray->getElementType();
2563
31
      while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2564
4
        auto *CArray = cast<ConstantArrayType>(Array);
2565
4
        ElCount *= CArray->getSize().getZExtValue();
2566
4
        FQT = CArray->getElementType();
2567
4
      }
2568
27
      if (FQT->isRecordType() && 
ElCount4
) {
2569
4
        int OldIndex = RunSkipBlockVars.size() - 1;
2570
4
        auto *RT = FQT->castAs<RecordType>();
2571
4
        BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset, HasUnion);
2572
2573
        // Replicate layout information for each array element. Note that
2574
        // one element is already done.
2575
4
        uint64_t ElIx = 1;
2576
16
        for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; 
ElIx++12
) {
2577
12
          CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2578
36
          for (int i = OldIndex+1; i <= FirstIndex; 
++i24
)
2579
24
            RunSkipBlockVars.push_back(
2580
24
              RUN_SKIP(RunSkipBlockVars[i].opcode,
2581
24
              RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2582
24
              RunSkipBlockVars[i].block_var_size));
2583
12
        }
2584
4
        continue;
2585
4
      }
2586
159
    }
2587
159
    CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2588
159
    if (IsUnion) {
2589
32
      CharUnits UnionIvarSize = FieldSize;
2590
32
      if (UnionIvarSize > MaxUnionSize) {
2591
8
        MaxUnionSize = UnionIvarSize;
2592
8
        MaxField = Field;
2593
8
        MaxFieldOffset = FieldOffset;
2594
8
      }
2595
127
    } else {
2596
127
      UpdateRunSkipBlockVars(false,
2597
127
                             getBlockCaptureLifetime(FQT, ByrefLayout),
2598
127
                             BytePos + FieldOffset,
2599
127
                             FieldSize);
2600
127
    }
2601
159
  }
2602
2603
127
  if (LastFieldBitfieldOrUnnamed) {
2604
34
    if (LastFieldBitfieldOrUnnamed->isBitField()) {
2605
      // Last field was a bitfield. Must update the info.
2606
24
      uint64_t BitFieldSize
2607
24
        = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2608
24
      unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2609
24
                        ((BitFieldSize % ByteSizeInBits) != 0);
2610
24
      CharUnits Size = CharUnits::fromQuantity(UnsSize);
2611
24
      Size += LastBitfieldOrUnnamedOffset;
2612
24
      UpdateRunSkipBlockVars(false,
2613
24
                             getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2614
24
                                                     ByrefLayout),
2615
24
                             BytePos + LastBitfieldOrUnnamedOffset,
2616
24
                             Size);
2617
10
    } else {
2618
10
      assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2619
      // Last field was unnamed. Must update skip info.
2620
10
      CharUnits FieldSize
2621
10
        = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2622
10
      UpdateRunSkipBlockVars(false,
2623
10
                             getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2624
10
                                                     ByrefLayout),
2625
10
                             BytePos + LastBitfieldOrUnnamedOffset,
2626
10
                             FieldSize);
2627
10
    }
2628
34
  }
2629
2630
127
  if (MaxField)
2631
8
    UpdateRunSkipBlockVars(false,
2632
8
                           getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2633
8
                           BytePos + MaxFieldOffset,
2634
8
                           MaxUnionSize);
2635
127
}
2636
2637
void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2638
                                                  CharUnits BytePos,
2639
                                                  bool &HasUnion,
2640
151
                                                  bool ByrefLayout) {
2641
151
  const RecordDecl *RD = RT->getDecl();
2642
151
  SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2643
151
  llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2644
151
  const llvm::StructLayout *RecLayout =
2645
151
    CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2646
2647
151
  BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2648
151
}
2649
2650
/// InlineLayoutInstruction - This routine produce an inline instruction for the
2651
/// block variable layout if it can. If not, it returns 0. Rules are as follow:
2652
/// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2653
/// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2654
/// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2655
/// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2656
/// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2657
/// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2658
/// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2659
uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2660
219
                                    SmallVectorImpl<unsigned char> &Layout) {
2661
219
  uint64_t Result = 0;
2662
219
  if (Layout.size() <= 3) {
2663
213
    unsigned size = Layout.size();
2664
213
    unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2665
213
    unsigned char inst;
2666
213
    enum BLOCK_LAYOUT_OPCODE opcode ;
2667
213
    switch (size) {
2668
11
      case 3:
2669
11
        inst = Layout[0];
2670
11
        opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2671
11
        if (opcode == BLOCK_LAYOUT_STRONG)
2672
11
          strong_word_count = (inst & 0xF)+1;
2673
0
        else
2674
0
          return 0;
2675
11
        inst = Layout[1];
2676
11
        opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2677
11
        if (opcode == BLOCK_LAYOUT_BYREF)
2678
9
          byref_word_count = (inst & 0xF)+1;
2679
2
        else
2680
2
          return 0;
2681
9
        inst = Layout[2];
2682
9
        opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2683
9
        if (opcode == BLOCK_LAYOUT_WEAK)
2684
9
          weak_word_count = (inst & 0xF)+1;
2685
0
        else
2686
0
          return 0;
2687
9
        break;
2688
2689
43
      case 2:
2690
43
        inst = Layout[0];
2691
43
        opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2692
43
        if (opcode == BLOCK_LAYOUT_STRONG) {
2693
26
          strong_word_count = (inst & 0xF)+1;
2694
26
          inst = Layout[1];
2695
26
          opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2696
26
          if (opcode == BLOCK_LAYOUT_BYREF)
2697
16
            byref_word_count = (inst & 0xF)+1;
2698
10
          else if (opcode == BLOCK_LAYOUT_WEAK)
2699
8
            weak_word_count = (inst & 0xF)+1;
2700
2
          else
2701
2
            return 0;
2702
17
        }
2703
17
        else if (opcode == BLOCK_LAYOUT_BYREF) {
2704
2
          byref_word_count = (inst & 0xF)+1;
2705
2
          inst = Layout[1];
2706
2
          opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2707
2
          if (opcode == BLOCK_LAYOUT_WEAK)
2708
2
            weak_word_count = (inst & 0xF)+1;
2709
0
          else
2710
0
            return 0;
2711
15
        }
2712
15
        else
2713
15
          return 0;
2714
26
        break;
2715
2716
121
      case 1:
2717
121
        inst = Layout[0];
2718
121
        opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2719
121
        if (opcode == BLOCK_LAYOUT_STRONG)
2720
67
          strong_word_count = (inst & 0xF)+1;
2721
54
        else if (opcode == BLOCK_LAYOUT_BYREF)
2722
35
          byref_word_count = (inst & 0xF)+1;
2723
19
        else if (opcode == BLOCK_LAYOUT_WEAK)
2724
14
          weak_word_count = (inst & 0xF)+1;
2725
5
        else
2726
5
          return 0;
2727
116
        break;
2728
2729
38
      default:
2730
38
        return 0;
2731
151
    }
2732
2733
    // Cannot inline when any of the word counts is 15. Because this is one less
2734
    // than the actual work count (so 15 means 16 actual word counts),
2735
    // and we can only display 0 thru 15 word counts.
2736
151
    if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2737
2
      return 0;
2738
2739
149
    unsigned count =
2740
149
      (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2741
2742
149
    if (size == count) {
2743
149
      if (strong_word_count)
2744
98
        Result = strong_word_count;
2745
149
      Result <<= 4;
2746
149
      if (byref_word_count)
2747
62
        Result += byref_word_count;
2748
149
      Result <<= 4;
2749
149
      if (weak_word_count)
2750
31
        Result += weak_word_count;
2751
149
    }
2752
149
  }
2753
155
  return Result;
2754
219
}
2755
2756
274
llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2757
274
  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2758
274
  if (RunSkipBlockVars.empty())
2759
55
    return nullPtr;
2760
219
  unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2761
219
  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2762
219
  unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2763
2764
  // Sort on byte position; captures might not be allocated in order,
2765
  // and unions can do funny things.
2766
219
  llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2767
219
  SmallVector<unsigned char, 16> Layout;
2768
2769
219
  unsigned size = RunSkipBlockVars.size();
2770
552
  for (unsigned i = 0; i < size; 
i++333
) {
2771
333
    enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2772
333
    CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2773
333
    CharUnits end_byte_pos = start_byte_pos;
2774
333
    unsigned j = i+1;
2775
567
    while (j < size) {
2776
348
      if (opcode == RunSkipBlockVars[j].opcode) {
2777
234
        end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2778
234
        i++;
2779
234
      }
2780
114
      else
2781
114
        break;
2782
348
    }
2783
333
    CharUnits size_in_bytes =
2784
333
    end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2785
333
    if (j < size) {
2786
114
      CharUnits gap =
2787
114
      RunSkipBlockVars[j].block_var_bytepos -
2788
114
      RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2789
114
      size_in_bytes += gap;
2790
114
    }
2791
333
    CharUnits residue_in_bytes = CharUnits::Zero();
2792
333
    if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2793
88
      residue_in_bytes = size_in_bytes % WordSizeInBytes;
2794
88
      size_in_bytes -= residue_in_bytes;
2795
88
      opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2796
88
    }
2797
2798
333
    unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2799
339
    while (size_in_words >= 16) {
2800
      // Note that value in imm. is one less that the actual
2801
      // value. So, 0xf means 16 words follow!
2802
6
      unsigned char inst = (opcode << 4) | 0xf;
2803
6
      Layout.push_back(inst);
2804
6
      size_in_words -= 16;
2805
6
    }
2806
333
    if (size_in_words > 0) {
2807
      // Note that value in imm. is one less that the actual
2808
      // value. So, we subtract 1 away!
2809
306
      unsigned char inst = (opcode << 4) | (size_in_words-1);
2810
306
      Layout.push_back(inst);
2811
306
    }
2812
333
    if (residue_in_bytes > CharUnits::Zero()) {
2813
33
      unsigned char inst =
2814
33
      (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2815
33
      Layout.push_back(inst);
2816
33
    }
2817
333
  }
2818
2819
288
  while (!Layout.empty()) {
2820
250
    unsigned char inst = Layout.back();
2821
250
    enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2822
250
    if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || 
opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS217
)
2823
69
      Layout.pop_back();
2824
181
    else
2825
181
      break;
2826
250
  }
2827
2828
219
  uint64_t Result = InlineLayoutInstruction(Layout);
2829
219
  if (Result != 0) {
2830
    // Block variable layout instruction has been inlined.
2831
149
    if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2832
40
      if (ComputeByrefLayout)
2833
0
        printf("\n Inline BYREF variable layout: ");
2834
40
      else
2835
40
        printf("\n Inline block variable layout: ");
2836
40
      printf("0x0%" PRIx64 "", Result);
2837
40
      if (auto numStrong = (Result & 0xF00) >> 8)
2838
32
        printf(", BL_STRONG:%d", (int) numStrong);
2839
40
      if (auto numByref = (Result & 0x0F0) >> 4)
2840
24
        printf(", BL_BYREF:%d", (int) numByref);
2841
40
      if (auto numWeak = (Result & 0x00F) >> 0)
2842
16
        printf(", BL_WEAK:%d", (int) numWeak);
2843
40
      printf(", BL_OPERATOR:0\n");
2844
40
    }
2845
149
    return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2846
149
  }
2847
2848
70
  unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2849
70
  Layout.push_back(inst);
2850
70
  std::string BitMap;
2851
225
  for (unsigned i = 0, e = Layout.size(); i != e; 
i++155
)
2852
155
    BitMap += Layout[i];
2853
2854
70
  if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2855
27
    if (ComputeByrefLayout)
2856
0
      printf("\n Byref variable layout: ");
2857
27
    else
2858
27
      printf("\n Block variable layout: ");
2859
100
    for (unsigned i = 0, e = BitMap.size(); i != e; 
i++73
) {
2860
73
      unsigned char inst = BitMap[i];
2861
73
      enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2862
73
      unsigned delta = 1;
2863
73
      switch (opcode) {
2864
27
        case BLOCK_LAYOUT_OPERATOR:
2865
27
          printf("BL_OPERATOR:");
2866
27
          delta = 0;
2867
27
          break;
2868
0
        case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2869
0
          printf("BL_NON_OBJECT_BYTES:");
2870
0
          break;
2871
14
        case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2872
14
          printf("BL_NON_OBJECT_WORD:");
2873
14
          break;
2874
4
        case BLOCK_LAYOUT_STRONG:
2875
4
          printf("BL_STRONG:");
2876
4
          break;
2877
2
        case BLOCK_LAYOUT_BYREF:
2878
2
          printf("BL_BYREF:");
2879
2
          break;
2880
8
        case BLOCK_LAYOUT_WEAK:
2881
8
          printf("BL_WEAK:");
2882
8
          break;
2883
18
        case BLOCK_LAYOUT_UNRETAINED:
2884
18
          printf("BL_UNRETAINED:");
2885
18
          break;
2886
73
      }
2887
      // Actual value of word count is one more that what is in the imm.
2888
      // field of the instruction
2889
73
      printf("%d", (inst & 0xf) + delta);
2890
73
      if (i < e-1)
2891
46
        printf(", ");
2892
27
      else
2893
27
        printf("\n");
2894
73
    }
2895
27
  }
2896
2897
70
  auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2898
70
                                     /*ForceNonFragileABI=*/true,
2899
70
                                     /*NullTerminate=*/false);
2900
70
  return getConstantGEP(VMContext, Entry, 0, 0);
2901
70
}
2902
2903
static std::string getBlockLayoutInfoString(
2904
    const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
2905
365
    bool HasCopyDisposeHelpers) {
2906
365
  std::string Str;
2907
626
  for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
2908
626
    if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
2909
      // Copy/dispose helpers don't have any information about
2910
      // __unsafe_unretained captures, so unconditionally concatenate a string.
2911
28
      Str += "u";
2912
598
    } else if (HasCopyDisposeHelpers) {
2913
      // Information about __strong, __weak, or byref captures has already been
2914
      // encoded into the names of the copy/dispose helpers. We have to add a
2915
      // string here only when the copy/dispose helpers aren't generated (which
2916
      // happens when the block is non-escaping).
2917
523
      continue;
2918
75
    } else {
2919
75
      switch (R.opcode) {
2920
18
      case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
2921
18
        Str += "s";
2922
18
        break;
2923
4
      case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
2924
4
        Str += "r";
2925
4
        break;
2926
0
      case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
2927
0
        Str += "w";
2928
0
        break;
2929
53
      default:
2930
53
        continue;
2931
50
      }
2932
50
    }
2933
50
    Str += llvm::to_string(R.block_var_bytepos.getQuantity());
2934
50
    Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
2935
50
  }
2936
365
  return Str;
2937
365
}
2938
2939
void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
2940
624
                                           const CGBlockInfo &blockInfo) {
2941
624
  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2942
2943
624
  RunSkipBlockVars.clear();
2944
624
  bool hasUnion = false;
2945
2946
624
  unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2947
624
  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2948
624
  unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2949
2950
624
  const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2951
2952
  // Calculate the basic layout of the block structure.
2953
624
  const llvm::StructLayout *layout =
2954
624
  CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2955
2956
  // Ignore the optional 'this' capture: C++ objects are not assumed
2957
  // to be GC'ed.
2958
624
  if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2959
2
    UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2960
2
                           blockInfo.BlockHeaderForcedGapOffset,
2961
2
                           blockInfo.BlockHeaderForcedGapSize);
2962
  // Walk the captured variables.
2963
1.10k
  for (const auto &CI : blockDecl->captures()) {
2964
1.10k
    const VarDecl *variable = CI.getVariable();
2965
1.10k
    QualType type = variable->getType();
2966
2967
1.10k
    const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2968
2969
    // Ignore constant captures.
2970
1.10k
    if (capture.isConstant()) 
continue0
;
2971
2972
1.10k
    CharUnits fieldOffset =
2973
1.10k
       CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2974
2975
1.10k
    assert(!type->isArrayType() && "array variable should not be caught");
2976
1.10k
    if (!CI.isByRef())
2977
870
      if (const RecordType *record = type->getAs<RecordType>()) {
2978
108
        BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2979
108
        continue;
2980
108
      }
2981
998
    CharUnits fieldSize;
2982
998
    if (CI.isByRef())
2983
236
      fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2984
762
    else
2985
762
      fieldSize = CGM.getContext().getTypeSizeInChars(type);
2986
998
    UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2987
998
                           fieldOffset, fieldSize);
2988
998
  }
2989
624
}
2990
2991
llvm::Constant *
2992
CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2993
259
                                    const CGBlockInfo &blockInfo) {
2994
259
  fillRunSkipBlockVars(CGM, blockInfo);
2995
259
  return getBitmapBlockLayout(false);
2996
259
}
2997
2998
std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
2999
365
                                                 const CGBlockInfo &blockInfo) {
3000
365
  fillRunSkipBlockVars(CGM, blockInfo);
3001
365
  return getBlockLayoutInfoString(RunSkipBlockVars,
3002
365
                                  blockInfo.needsCopyDisposeHelpers());
3003
365
}
3004
3005
llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
3006
15
                                                  QualType T) {
3007
15
  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3008
15
  assert(!T->isArrayType() && "__block array variable should not be caught");
3009
15
  CharUnits fieldOffset;
3010
15
  RunSkipBlockVars.clear();
3011
15
  bool hasUnion = false;
3012
15
  if (const RecordType *record = T->getAs<RecordType>()) {
3013
15
    BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
3014
15
    llvm::Constant *Result = getBitmapBlockLayout(true);
3015
15
    if (isa<llvm::ConstantInt>(Result))
3016
1
      Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
3017
15
    return Result;
3018
15
  }
3019
0
  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
3020
0
  return nullPtr;
3021
0
}
3022
3023
llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
3024
4
                                            const ObjCProtocolDecl *PD) {
3025
  // FIXME: I don't understand why gcc generates this, or where it is
3026
  // resolved. Investigate. Its also wasteful to look this up over and over.
3027
4
  LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3028
3029
4
  return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
3030
4
                                        ObjCTypes.getExternalProtocolPtrTy());
3031
4
}
3032
3033
19.9k
void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
3034
  // FIXME: We shouldn't need this, the protocol decl should contain enough
3035
  // information to tell us whether this was a declaration or a definition.
3036
19.9k
  DefinedProtocols.insert(PD->getIdentifier());
3037
3038
  // If we have generated a forward reference to this protocol, emit
3039
  // it now. Otherwise do nothing, the protocol objects are lazily
3040
  // emitted.
3041
19.9k
  if (Protocols.count(PD->getIdentifier()))
3042
0
    GetOrEmitProtocol(PD);
3043
19.9k
}
3044
3045
117
llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
3046
117
  if (DefinedProtocols.count(PD->getIdentifier()))
3047
114
    return GetOrEmitProtocol(PD);
3048
3049
3
  return GetOrEmitProtocolRef(PD);
3050
3
}
3051
3052
llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
3053
               CodeGenFunction &CGF,
3054
               const ObjCInterfaceDecl *ID,
3055
2
               ObjCCommonTypesHelper &ObjCTypes) {
3056
2
  llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn();
3057
3058
2
  llvm::Value *className = CGF.CGM
3059
2
                               .GetAddrOfConstantCString(std::string(
3060
2
                                   ID->getObjCRuntimeNameAsString()))
3061
2
                               .getPointer();
3062
2
  ASTContext &ctx = CGF.CGM.getContext();
3063
2
  className =
3064
2
      CGF.Builder.CreateBitCast(className,
3065
2
                                CGF.ConvertType(
3066
2
                                  ctx.getPointerType(ctx.CharTy.withConst())));
3067
2
  llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
3068
2
  call->setDoesNotThrow();
3069
2
  return call;
3070
2
}
3071
3072
/*
3073
// Objective-C 1.0 extensions
3074
struct _objc_protocol {
3075
struct _objc_protocol_extension *isa;
3076
char *protocol_name;
3077
struct _objc_protocol_list *protocol_list;
3078
struct _objc__method_prototype_list *instance_methods;
3079
struct _objc__method_prototype_list *class_methods
3080
};
3081
3082
See EmitProtocolExtension().
3083
*/
3084
16
llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
3085
16
  llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
3086
3087
  // Early exit if a defining object has already been generated.
3088
16
  if (Entry && 
Entry->hasInitializer()1
)
3089
1
    return Entry;
3090
3091
  // Use the protocol definition, if there is one.
3092
15
  if (const ObjCProtocolDecl *Def = PD->getDefinition())
3093
15
    PD = Def;
3094
3095
  // FIXME: I don't understand why gcc generates this, or where it is
3096
  // resolved. Investigate. Its also wasteful to look this up over and over.
3097
15
  LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3098
3099
  // Construct method lists.
3100
15
  auto methodLists = ProtocolMethodLists::get(PD);
3101
3102
15
  ConstantInitBuilder builder(CGM);
3103
15
  auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3104
15
  values.add(EmitProtocolExtension(PD, methodLists));
3105
15
  values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3106
15
  values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3107
15
                              PD->protocol_begin(), PD->protocol_end()));
3108
15
  values.add(methodLists.emitMethodList(this, PD,
3109
15
                              ProtocolMethodLists::RequiredInstanceMethods));
3110
15
  values.add(methodLists.emitMethodList(this, PD,
3111
15
                              ProtocolMethodLists::RequiredClassMethods));
3112
3113
15
  if (Entry) {
3114
    // Already created, update the initializer.
3115
0
    assert(Entry->hasPrivateLinkage());
3116
0
    values.finishAndSetAsInitializer(Entry);
3117
15
  } else {
3118
15
    Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3119
15
                                         CGM.getPointerAlign(),
3120
15
                                         /*constant*/ false,
3121
15
                                         llvm::GlobalValue::PrivateLinkage);
3122
15
    Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3123
3124
15
    Protocols[PD->getIdentifier()] = Entry;
3125
15
  }
3126
15
  CGM.addCompilerUsedGlobal(Entry);
3127
3128
15
  return Entry;
3129
15
}
3130
3131
1
llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3132
1
  llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3133
3134
1
  if (!Entry) {
3135
    // We use the initializer as a marker of whether this is a forward
3136
    // reference or not. At module finalization we add the empty
3137
    // contents for protocols which were referenced but never defined.
3138
1
    Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3139
1
                                     false, llvm::GlobalValue::PrivateLinkage,
3140
1
                                     nullptr, "OBJC_PROTOCOL_" + PD->getName());
3141
1
    Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3142
    // FIXME: Is this necessary? Why only for protocol?
3143
1
    Entry->setAlignment(llvm::Align(4));
3144
1
  }
3145
3146
1
  return Entry;
3147
1
}
3148
3149
/*
3150
  struct _objc_protocol_extension {
3151
  uint32_t size;
3152
  struct objc_method_description_list *optional_instance_methods;
3153
  struct objc_method_description_list *optional_class_methods;
3154
  struct objc_property_list *instance_properties;
3155
  const char ** extendedMethodTypes;
3156
  struct objc_property_list *class_properties;
3157
  };
3158
*/
3159
llvm::Constant *
3160
CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3161
15
                                 const ProtocolMethodLists &methodLists) {
3162
15
  auto optInstanceMethods =
3163
15
    methodLists.emitMethodList(this, PD,
3164
15
                               ProtocolMethodLists::OptionalInstanceMethods);
3165
15
  auto optClassMethods =
3166
15
    methodLists.emitMethodList(this, PD,
3167
15
                               ProtocolMethodLists::OptionalClassMethods);
3168
3169
15
  auto extendedMethodTypes =
3170
15
    EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3171
15
                            methodLists.emitExtendedTypesArray(this),
3172
15
                            ObjCTypes);
3173
3174
15
  auto instanceProperties =
3175
15
    EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3176
15
                     ObjCTypes, false);
3177
15
  auto classProperties =
3178
15
    EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3179
15
                     PD, ObjCTypes, true);
3180
3181
  // Return null if no extension bits are used.
3182
15
  if (optInstanceMethods->isNullValue() &&
3183
15
      optClassMethods->isNullValue() &&
3184
15
      extendedMethodTypes->isNullValue() &&
3185
9
      instanceProperties->isNullValue() &&
3186
9
      classProperties->isNullValue()) {
3187
9
    return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3188
9
  }
3189
3190
6
  uint64_t size =
3191
6
    CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3192
3193
6
  ConstantInitBuilder builder(CGM);
3194
6
  auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3195
6
  values.addInt(ObjCTypes.IntTy, size);
3196
6
  values.add(optInstanceMethods);
3197
6
  values.add(optClassMethods);
3198
6
  values.add(instanceProperties);
3199
6
  values.add(extendedMethodTypes);
3200
6
  values.add(classProperties);
3201
3202
  // No special section, but goes in llvm.used
3203
6
  return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3204
6
                           StringRef(), CGM.getPointerAlign(), true);
3205
6
}
3206
3207
/*
3208
  struct objc_protocol_list {
3209
    struct objc_protocol_list *next;
3210
    long count;
3211
    Protocol *list[];
3212
  };
3213
*/
3214
llvm::Constant *
3215
CGObjCMac::EmitProtocolList(Twine name,
3216
                            ObjCProtocolDecl::protocol_iterator begin,
3217
143
                            ObjCProtocolDecl::protocol_iterator end) {
3218
  // Just return null for empty protocol lists
3219
143
  auto PDs = GetRuntimeProtocolList(begin, end);
3220
143
  if (PDs.empty())
3221
132
    return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3222
3223
11
  ConstantInitBuilder builder(CGM);
3224
11
  auto values = builder.beginStruct();
3225
3226
  // This field is only used by the runtime.
3227
11
  values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3228
3229
  // Reserve a slot for the count.
3230
11
  auto countSlot = values.addPlaceholder();
3231
3232
11
  auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3233
11
  for (const auto *Proto : PDs)
3234
13
    refsArray.add(GetProtocolRef(Proto));
3235
3236
11
  auto count = refsArray.size();
3237
3238
  // This list is null terminated.
3239
11
  refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3240
3241
11
  refsArray.finishAndAddTo(values);
3242
11
  values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3243
3244
11
  StringRef section;
3245
11
  if (CGM.getTriple().isOSBinFormatMachO())
3246
11
    section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3247
3248
11
  llvm::GlobalVariable *GV =
3249
11
      CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3250
11
  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3251
11
}
3252
3253
static void
3254
PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3255
                       SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3256
                       const ObjCProtocolDecl *Proto,
3257
100
                       bool IsClassProperty) {
3258
37
  for (const auto *PD : Proto->properties()) {
3259
37
    if (IsClassProperty != PD->isClassProperty())
3260
7
      continue;
3261
30
    if (!PropertySet.insert(PD->getIdentifier()).second)
3262
7
      continue;
3263
23
    Properties.push_back(PD);
3264
23
  }
3265
3266
100
  for (const auto *P : Proto->protocols())
3267
30
    PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3268
100
}
3269
3270
/*
3271
  struct _objc_property {
3272
    const char * const name;
3273
    const char * const attributes;
3274
  };
3275
3276
  struct _objc_property_list {
3277
    uint32_t entsize; // sizeof (struct _objc_property)
3278
    uint32_t prop_count;
3279
    struct _objc_property[prop_count];
3280
  };
3281
*/
3282
llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3283
                                       const Decl *Container,
3284
                                       const ObjCContainerDecl *OCD,
3285
                                       const ObjCCommonTypesHelper &ObjCTypes,
3286
2.68k
                                       bool IsClassProperty) {
3287
2.68k
  if (IsClassProperty) {
3288
    // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3289
    // with deployment target < 9.0.
3290
1.34k
    const llvm::Triple &Triple = CGM.getTarget().getTriple();
3291
1.34k
    if ((Triple.isMacOSX() && 
Triple.isMacOSXVersionLT(10, 11)1.27k
) ||
3292
786
        (Triple.isiOS() && 
Triple.isOSVersionLT(9)20
))
3293
571
      return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3294
2.10k
  }
3295
3296
2.10k
  SmallVector<const ObjCPropertyDecl *, 16> Properties;
3297
2.10k
  llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3298
3299
2.10k
  if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3300
1.70k
    for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3301
68
      for (auto *PD : ClassExt->properties()) {
3302
32
        if (IsClassProperty != PD->isClassProperty())
3303
6
          continue;
3304
26
        if (PD->isDirectProperty())
3305
1
          continue;
3306
25
        PropertySet.insert(PD->getIdentifier());
3307
25
        Properties.push_back(PD);
3308
25
      }
3309
3310
671
  for (const auto *PD : OCD->properties()) {
3311
671
    if (IsClassProperty != PD->isClassProperty())
3312
230
      continue;
3313
    // Don't emit duplicate metadata for properties that were already in a
3314
    // class extension.
3315
441
    if (!PropertySet.insert(PD->getIdentifier()).second)
3316
7
      continue;
3317
434
    if (PD->isDirectProperty())
3318
4
      continue;
3319
430
    Properties.push_back(PD);
3320
430
  }
3321
3322
2.10k
  if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3323
1.70k
    for (const auto *P : OID->all_referenced_protocols())
3324
64
      PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3325
1.70k
  }
3326
400
  else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3327
311
    for (const auto *P : CD->protocols())
3328
6
      PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3329
311
  }
3330
3331
  // Return null for empty list.
3332
2.10k
  if (Properties.empty())
3333
1.82k
    return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3334
3335
287
  unsigned propertySize =
3336
287
    CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3337
3338
287
  ConstantInitBuilder builder(CGM);
3339
287
  auto values = builder.beginStruct();
3340
287
  values.addInt(ObjCTypes.IntTy, propertySize);
3341
287
  values.addInt(ObjCTypes.IntTy, Properties.size());
3342
287
  auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3343
478
  for (auto PD : Properties) {
3344
478
    auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3345
478
    property.add(GetPropertyName(PD->getIdentifier()));
3346
478
    property.add(GetPropertyTypeString(PD, Container));
3347
478
    property.finishAndAddTo(propertiesArray);
3348
478
  }
3349
287
  propertiesArray.finishAndAddTo(values);
3350
3351
287
  StringRef Section;
3352
287
  if (CGM.getTriple().isOSBinFormatMachO())
3353
280
    Section = (ObjCABI == 2) ? 
"__DATA, __objc_const"265
3354
15
                             : "__OBJC,__property,regular,no_dead_strip";
3355
3356
287
  llvm::GlobalVariable *GV =
3357
287
      CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3358
287
  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3359
287
}
3360
3361
llvm::Constant *
3362
CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3363
                                         ArrayRef<llvm::Constant*> MethodTypes,
3364
75
                                         const ObjCCommonTypesHelper &ObjCTypes) {
3365
  // Return null for empty list.
3366
75
  if (MethodTypes.empty())
3367
31
    return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3368
3369
44
  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3370
44
                                             MethodTypes.size());
3371
44
  llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3372
3373
44
  StringRef Section;
3374
44
  if (CGM.getTriple().isOSBinFormatMachO() && 
ObjCABI == 242
)
3375
36
    Section = "__DATA, __objc_const";
3376
3377
44
  llvm::GlobalVariable *GV =
3378
44
      CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3379
44
  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3380
44
}
3381
3382
/*
3383
  struct _objc_category {
3384
  char *category_name;
3385
  char *class_name;
3386
  struct _objc_method_list *instance_methods;
3387
  struct _objc_method_list *class_methods;
3388
  struct _objc_protocol_list *protocols;
3389
  uint32_t size; // <rdar://4585769>
3390
  struct _objc_property_list *instance_properties;
3391
  struct _objc_property_list *class_properties;
3392
  };
3393
*/
3394
7
void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3395
7
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3396
3397
  // FIXME: This is poor design, the OCD should have a pointer to the category
3398
  // decl. Additionally, note that Category can be null for the @implementation
3399
  // w/o an @interface case. Sema should just create one for us as it does for
3400
  // @implementation so everyone else can live life under a clear blue sky.
3401
7
  const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3402
7
  const ObjCCategoryDecl *Category =
3403
7
    Interface->FindCategoryDeclaration(OCD->getIdentifier());
3404
3405
7
  SmallString<256> ExtName;
3406
7
  llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3407
7
                                     << OCD->getName();
3408
3409
7
  ConstantInitBuilder Builder(CGM);
3410
7
  auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3411
3412
7
  enum {
3413
7
    InstanceMethods,
3414
7
    ClassMethods,
3415
7
    NumMethodLists
3416
7
  };
3417
7
  SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3418
6
  for (const auto *MD : OCD->methods()) {
3419
6
    if (!MD->isDirectMethod())
3420
6
      Methods[unsigned(MD->isClassMethod())].push_back(MD);
3421
6
  }
3422
3423
7
  Values.add(GetClassName(OCD->getName()));
3424
7
  Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3425
7
  LazySymbols.insert(Interface->getIdentifier());
3426
3427
7
  Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3428
7
                            Methods[InstanceMethods]));
3429
7
  Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3430
7
                            Methods[ClassMethods]));
3431
7
  if (Category) {
3432
7
    Values.add(
3433
7
        EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3434
7
                         Category->protocol_begin(), Category->protocol_end()));
3435
0
  } else {
3436
0
    Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3437
0
  }
3438
7
  Values.addInt(ObjCTypes.IntTy, Size);
3439
3440
  // If there is no category @interface then there can be no properties.
3441
7
  if (Category) {
3442
7
    Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
3443
7
                                OCD, Category, ObjCTypes, false));
3444
7
    Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3445
7
                                OCD, Category, ObjCTypes, true));
3446
0
  } else {
3447
0
    Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3448
0
    Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3449
0
  }
3450
3451
7
  llvm::GlobalVariable *GV =
3452
7
      CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3453
7
                        "__OBJC,__category,regular,no_dead_strip",
3454
7
                        CGM.getPointerAlign(), true);
3455
7
  DefinedCategories.push_back(GV);
3456
7
  DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3457
  // method definition entries must be clear for next implementation.
3458
7
  MethodDefinitions.clear();
3459
7
}
3460
3461
enum FragileClassFlags {
3462
  /// Apparently: is not a meta-class.
3463
  FragileABI_Class_Factory                 = 0x00001,
3464
3465
  /// Is a meta-class.
3466
  FragileABI_Class_Meta                    = 0x00002,
3467
3468
  /// Has a non-trivial constructor or destructor.
3469
  FragileABI_Class_HasCXXStructors         = 0x02000,
3470
3471
  /// Has hidden visibility.
3472
  FragileABI_Class_Hidden                  = 0x20000,
3473
3474
  /// Class implementation was compiled under ARC.
3475
  FragileABI_Class_CompiledByARC           = 0x04000000,
3476
3477
  /// Class implementation was compiled under MRC and has MRC weak ivars.
3478
  /// Exclusive with CompiledByARC.
3479
  FragileABI_Class_HasMRCWeakIvars         = 0x08000000,
3480
};
3481
3482
enum NonFragileClassFlags {
3483
  /// Is a meta-class.
3484
  NonFragileABI_Class_Meta                 = 0x00001,
3485
3486
  /// Is a root class.
3487
  NonFragileABI_Class_Root                 = 0x00002,
3488
3489
  /// Has a non-trivial constructor or destructor.
3490
  NonFragileABI_Class_HasCXXStructors      = 0x00004,
3491
3492
  /// Has hidden visibility.
3493
  NonFragileABI_Class_Hidden               = 0x00010,
3494
3495
  /// Has the exception attribute.
3496
  NonFragileABI_Class_Exception            = 0x00020,
3497
3498
  /// (Obsolete) ARC-specific: this class has a .release_ivars method
3499
  NonFragileABI_Class_HasIvarReleaser      = 0x00040,
3500
3501
  /// Class implementation was compiled under ARC.
3502
  NonFragileABI_Class_CompiledByARC        = 0x00080,
3503
3504
  /// Class has non-trivial destructors, but zero-initialization is okay.
3505
  NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3506
3507
  /// Class implementation was compiled under MRC and has MRC weak ivars.
3508
  /// Exclusive with CompiledByARC.
3509
  NonFragileABI_Class_HasMRCWeakIvars      = 0x00200,
3510
};
3511
3512
17
static bool hasWeakMember(QualType type) {
3513
17
  if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3514
11
    return true;
3515
11
  }
3516
3517
6
  if (auto recType = type->getAs<RecordType>()) {
3518
0
    for (auto field : recType->getDecl()->fields()) {
3519
0
      if (hasWeakMember(field->getType()))
3520
0
        return true;
3521
0
    }
3522
0
  }
3523
3524
6
  return false;
3525
6
}
3526
3527
/// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3528
/// (and actually fill in a layout string) if we really do have any
3529
/// __weak ivars.
3530
static bool hasMRCWeakIvars(CodeGenModule &CGM,
3531
1.77k
                            const ObjCImplementationDecl *ID) {
3532
1.77k
  if (!CGM.getLangOpts().ObjCWeak) 
return false1.76k
;
3533
13
  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3534
3535
13
  for (const ObjCIvarDecl *ivar =
3536
13
         ID->getClassInterface()->all_declared_ivar_begin();
3537
19
       ivar; 
ivar = ivar->getNextIvar()6
) {
3538
17
    if (hasWeakMember(ivar->getType()))
3539
11
      return true;
3540
17
  }
3541
3542
2
  return false;
3543
13
}
3544
3545
/*
3546
  struct _objc_class {
3547
  Class isa;
3548
  Class super_class;
3549
  const char *name;
3550
  long version;
3551
  long info;
3552
  long instance_size;
3553
  struct _objc_ivar_list *ivars;
3554
  struct _objc_method_list *methods;
3555
  struct _objc_cache *cache;
3556
  struct _objc_protocol_list *protocols;
3557
  // Objective-C 1.0 extensions (<rdr://4585769>)
3558
  const char *ivar_layout;
3559
  struct _objc_class_ext *ext;
3560
  };
3561
3562
  See EmitClassExtension();
3563
*/
3564
121
void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3565
121
  IdentifierInfo *RuntimeName =
3566
121
      &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3567
121
  DefinedSymbols.insert(RuntimeName);
3568
3569
121
  std::string ClassName = ID->getNameAsString();
3570
  // FIXME: Gross
3571
121
  ObjCInterfaceDecl *Interface =
3572
121
    const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3573
121
  llvm::Constant *Protocols =
3574
121
      EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3575
121
                       Interface->all_referenced_protocol_begin(),
3576
121
                       Interface->all_referenced_protocol_end());
3577
121
  unsigned Flags = FragileABI_Class_Factory;
3578
121
  if (ID->hasNonZeroConstructors() || 
ID->hasDestructors()120
)
3579
8
    Flags |= FragileABI_Class_HasCXXStructors;
3580
3581
121
  bool hasMRCWeak = false;
3582
3583
121
  if (CGM.getLangOpts().ObjCAutoRefCount)
3584
4
    Flags |= FragileABI_Class_CompiledByARC;
3585
117
  else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3586
3
    Flags |= FragileABI_Class_HasMRCWeakIvars;
3587
3588
121
  CharUnits Size =
3589
121
    CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3590
3591
  // FIXME: Set CXX-structors flag.
3592
121
  if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3593
0
    Flags |= FragileABI_Class_Hidden;
3594
3595
121
  enum {
3596
121
    InstanceMethods,
3597
121
    ClassMethods,
3598
121
    NumMethodLists
3599
121
  };
3600
121
  SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3601
170
  for (const auto *MD : ID->methods()) {
3602
170
    if (!MD->isDirectMethod())
3603
170
      Methods[unsigned(MD->isClassMethod())].push_back(MD);
3604
170
  }
3605
3606
17
  for (const auto *PID : ID->property_impls()) {
3607
17
    if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3608
13
      if (PID->getPropertyDecl()->isDirectProperty())
3609
0
        continue;
3610
13
      if (ObjCMethodDecl *MD = PID->getGetterMethodDecl())
3611
13
        if (GetMethodDefinition(MD))
3612
13
          Methods[InstanceMethods].push_back(MD);
3613
13
      if (ObjCMethodDecl *MD = PID->getSetterMethodDecl())
3614
13
        if (GetMethodDefinition(MD))
3615
13
          Methods[InstanceMethods].push_back(MD);
3616
13
    }
3617
17
  }
3618
3619
121
  ConstantInitBuilder builder(CGM);
3620
121
  auto values = builder.beginStruct(ObjCTypes.ClassTy);
3621
121
  values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3622
121
  if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3623
    // Record a reference to the super class.
3624
39
    LazySymbols.insert(Super->getIdentifier());
3625
3626
39
    values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3627
39
                      ObjCTypes.ClassPtrTy);
3628
82
  } else {
3629
82
    values.addNullPointer(ObjCTypes.ClassPtrTy);
3630
82
  }
3631
121
  values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3632
  // Version is always 0.
3633
121
  values.addInt(ObjCTypes.LongTy, 0);
3634
121
  values.addInt(ObjCTypes.LongTy, Flags);
3635
121
  values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3636
121
  values.add(EmitIvarList(ID, false));
3637
121
  values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3638
121
                            Methods[InstanceMethods]));
3639
  // cache is always NULL.
3640
121
  values.addNullPointer(ObjCTypes.CachePtrTy);
3641
121
  values.add(Protocols);
3642
121
  values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3643
121
  values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3644
121
                                /*isMetaclass*/ false));
3645
3646
121
  std::string Name("OBJC_CLASS_");
3647
121
  Name += ClassName;
3648
121
  const char *Section = "__OBJC,__class,regular,no_dead_strip";
3649
  // Check for a forward reference.
3650
121
  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3651
121
  if (GV) {
3652
8
    assert(GV->getValueType() == ObjCTypes.ClassTy &&
3653
8
           "Forward metaclass reference has incorrect type.");
3654
8
    values.finishAndSetAsInitializer(GV);
3655
8
    GV->setSection(Section);
3656
8
    GV->setAlignment(CGM.getPointerAlign().getAsAlign());
3657
8
    CGM.addCompilerUsedGlobal(GV);
3658
8
  } else
3659
113
    GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3660
121
  DefinedClasses.push_back(GV);
3661
121
  ImplementedClasses.push_back(Interface);
3662
  // method definition entries must be clear for next implementation.
3663
121
  MethodDefinitions.clear();
3664
121
}
3665
3666
llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3667
                                         llvm::Constant *Protocols,
3668
121
                                ArrayRef<const ObjCMethodDecl*> Methods) {
3669
121
  unsigned Flags = FragileABI_Class_Meta;
3670
121
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3671
3672
121
  if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3673
0
    Flags |= FragileABI_Class_Hidden;
3674
3675
121
  ConstantInitBuilder builder(CGM);
3676
121
  auto values = builder.beginStruct(ObjCTypes.ClassTy);
3677
  // The isa for the metaclass is the root of the hierarchy.
3678
121
  const ObjCInterfaceDecl *Root = ID->getClassInterface();
3679
169
  while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3680
48
    Root = Super;
3681
121
  values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3682
121
                    ObjCTypes.ClassPtrTy);
3683
  // The super class for the metaclass is emitted as the name of the
3684
  // super class. The runtime fixes this up to point to the
3685
  // *metaclass* for the super class.
3686
121
  if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3687
39
    values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3688
39
                      ObjCTypes.ClassPtrTy);
3689
82
  } else {
3690
82
    values.addNullPointer(ObjCTypes.ClassPtrTy);
3691
82
  }
3692
121
  values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3693
  // Version is always 0.
3694
121
  values.addInt(ObjCTypes.LongTy, 0);
3695
121
  values.addInt(ObjCTypes.LongTy, Flags);
3696
121
  values.addInt(ObjCTypes.LongTy, Size);
3697
121
  values.add(EmitIvarList(ID, true));
3698
121
  values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3699
121
                            Methods));
3700
  // cache is always NULL.
3701
121
  values.addNullPointer(ObjCTypes.CachePtrTy);
3702
121
  values.add(Protocols);
3703
  // ivar_layout for metaclass is always NULL.
3704
121
  values.addNullPointer(ObjCTypes.Int8PtrTy);
3705
  // The class extension is used to store class properties for metaclasses.
3706
121
  values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3707
121
                                /*isMetaclass*/true));
3708
3709
121
  std::string Name("OBJC_METACLASS_");
3710
121
  Name += ID->getName();
3711
3712
  // Check for a forward reference.
3713
121
  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3714
121
  if (GV) {
3715
2
    assert(GV->getValueType() == ObjCTypes.ClassTy &&
3716
2
           "Forward metaclass reference has incorrect type.");
3717
2
    values.finishAndSetAsInitializer(GV);
3718
119
  } else {
3719
119
    GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3720
119
                                      /*constant*/ false,
3721
119
                                      llvm::GlobalValue::PrivateLinkage);
3722
119
  }
3723
121
  GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3724
121
  CGM.addCompilerUsedGlobal(GV);
3725
3726
121
  return GV;
3727
121
}
3728
3729
7
llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3730
7
  std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3731
3732
  // FIXME: Should we look these up somewhere other than the module. Its a bit
3733
  // silly since we only generate these while processing an implementation, so
3734
  // exactly one pointer would work if know when we entered/exitted an
3735
  // implementation block.
3736
3737
  // Check for an existing forward reference.
3738
  // Previously, metaclass with internal linkage may have been defined.
3739
  // pass 'true' as 2nd argument so it is returned.
3740
7
  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3741
7
  if (!GV)
3742
2
    GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3743
2
                                  llvm::GlobalValue::PrivateLinkage, nullptr,
3744
2
                                  Name);
3745
3746
7
  assert(GV->getValueType() == ObjCTypes.ClassTy &&
3747
7
         "Forward metaclass reference has incorrect type.");
3748
7
  return GV;
3749
7
}
3750
3751
16
llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3752
16
  std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3753
16
  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3754
3755
16
  if (!GV)
3756
8
    GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3757
8
                                  llvm::GlobalValue::PrivateLinkage, nullptr,
3758
8
                                  Name);
3759
3760
16
  assert(GV->getValueType() == ObjCTypes.ClassTy &&
3761
16
         "Forward class metadata reference has incorrect type.");
3762
16
  return GV;
3763
16
}
3764
3765
/*
3766
  Emit a "class extension", which in this specific context means extra
3767
  data that doesn't fit in the normal fragile-ABI class structure, and
3768
  has nothing to do with the language concept of a class extension.
3769
3770
  struct objc_class_ext {
3771
  uint32_t size;
3772
  const char *weak_ivar_layout;
3773
  struct _objc_property_list *properties;
3774
  };
3775
*/
3776
llvm::Constant *
3777
CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3778
                              CharUnits InstanceSize, bool hasMRCWeakIvars,
3779
242
                              bool isMetaclass) {
3780
  // Weak ivar layout.
3781
242
  llvm::Constant *layout;
3782
242
  if (isMetaclass) {
3783
121
    layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3784
121
  } else {
3785
121
    layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3786
121
                                 hasMRCWeakIvars);
3787
121
  }
3788
3789
  // Properties.
3790
242
  llvm::Constant *propertyList =
3791
121
    EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_")
3792
121
                                  : Twine("_OBJC_$_PROP_LIST_"))
3793
242
                        + ID->getName(),
3794
242
                     ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3795
3796
  // Return null if no extension bits are used.
3797
242
  if (layout->isNullValue() && 
propertyList->isNullValue()227
) {
3798
212
    return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3799
212
  }
3800
3801
30
  uint64_t size =
3802
30
    CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3803
3804
30
  ConstantInitBuilder builder(CGM);
3805
30
  auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3806
30
  values.addInt(ObjCTypes.IntTy, size);
3807
30
  values.add(layout);
3808
30
  values.add(propertyList);
3809
3810
30
  return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3811
30
                           "__OBJC,__class_ext,regular,no_dead_strip",
3812
30
                           CGM.getPointerAlign(), true);
3813
30
}
3814
3815
/*
3816
  struct objc_ivar {
3817
    char *ivar_name;
3818
    char *ivar_type;
3819
    int ivar_offset;
3820
  };
3821
3822
  struct objc_ivar_list {
3823
    int ivar_count;
3824
    struct objc_ivar list[count];
3825
  };
3826
*/
3827
llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3828
242
                                        bool ForClass) {
3829
  // When emitting the root class GCC emits ivar entries for the
3830
  // actual class structure. It is not clear if we need to follow this
3831
  // behavior; for now lets try and get away with not doing it. If so,
3832
  // the cleanest solution would be to make up an ObjCInterfaceDecl
3833
  // for the class.
3834
242
  if (ForClass)
3835
121
    return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3836
3837
121
  const ObjCInterfaceDecl *OID = ID->getClassInterface();
3838
3839
121
  ConstantInitBuilder builder(CGM);
3840
121
  auto ivarList = builder.beginStruct();
3841
121
  auto countSlot = ivarList.addPlaceholder();
3842
121
  auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3843
3844
121
  for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3845
299
       IVD; 
IVD = IVD->getNextIvar()178
) {
3846
    // Ignore unnamed bit-fields.
3847
178
    if (!IVD->getDeclName())
3848
0
      continue;
3849
3850
178
    auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3851
178
    ivar.add(GetMethodVarName(IVD->getIdentifier()));
3852
178
    ivar.add(GetMethodVarType(IVD));
3853
178
    ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3854
178
    ivar.finishAndAddTo(ivars);
3855
178
  }
3856
3857
  // Return null for empty list.
3858
121
  auto count = ivars.size();
3859
121
  if (count == 0) {
3860
54
    ivars.abandon();
3861
54
    ivarList.abandon();
3862
54
    return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3863
54
  }
3864
3865
67
  ivars.finishAndAddTo(ivarList);
3866
67
  ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3867
3868
67
  llvm::GlobalVariable *GV;
3869
67
  if (ForClass)
3870
0
    GV =
3871
0
        CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3872
0
                          "__OBJC,__class_vars,regular,no_dead_strip",
3873
0
                          CGM.getPointerAlign(), true);
3874
67
  else
3875
67
    GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3876
67
                           "__OBJC,__instance_vars,regular,no_dead_strip",
3877
67
                           CGM.getPointerAlign(), true);
3878
67
  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3879
67
}
3880
3881
/// Build a struct objc_method_description constant for the given method.
3882
///
3883
/// struct objc_method_description {
3884
///   SEL method_name;
3885
///   char *method_types;
3886
/// };
3887
void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3888
7
                                              const ObjCMethodDecl *MD) {
3889
7
  auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3890
7
  description.addBitCast(GetMethodVarName(MD->getSelector()),
3891
7
                         ObjCTypes.SelectorPtrTy);
3892
7
  description.add(GetMethodVarType(MD));
3893
7
  description.finishAndAddTo(builder);
3894
7
}
3895
3896
/// Build a struct objc_method constant for the given method.
3897
///
3898
/// struct objc_method {
3899
///   SEL method_name;
3900
///   char *method_types;
3901
///   void *method;
3902
/// };
3903
void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3904
202
                                   const ObjCMethodDecl *MD) {
3905
202
  llvm::Function *fn = GetMethodDefinition(MD);
3906
202
  assert(fn && "no definition registered for method");
3907
3908
202
  auto method = builder.beginStruct(ObjCTypes.MethodTy);
3909
202
  method.addBitCast(GetMethodVarName(MD->getSelector()),
3910
202
                    ObjCTypes.SelectorPtrTy);
3911
202
  method.add(GetMethodVarType(MD));
3912
202
  method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3913
202
  method.finishAndAddTo(builder);
3914
202
}
3915
3916
/// Build a struct objc_method_list or struct objc_method_description_list,
3917
/// as appropriate.
3918
///
3919
/// struct objc_method_list {
3920
///   struct objc_method_list *obsolete;
3921
///   int count;
3922
///   struct objc_method methods_list[count];
3923
/// };
3924
///
3925
/// struct objc_method_description_list {
3926
///   int count;
3927
///   struct objc_method_description list[count];
3928
/// };
3929
llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3930
316
                                 ArrayRef<const ObjCMethodDecl *> methods) {
3931
316
  StringRef prefix;
3932
316
  StringRef section;
3933
316
  bool forProtocol = false;
3934
316
  switch (MLT) {
3935
7
  case MethodListType::CategoryInstanceMethods:
3936
7
    prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3937
7
    section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3938
7
    forProtocol = false;
3939
7
    break;
3940
7
  case MethodListType::CategoryClassMethods:
3941
7
    prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3942
7
    section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3943
7
    forProtocol = false;
3944
7
    break;
3945
121
  case MethodListType::InstanceMethods:
3946
121
    prefix = "OBJC_INSTANCE_METHODS_";
3947
121
    section = "__OBJC,__inst_meth,regular,no_dead_strip";
3948
121
    forProtocol = false;
3949
121
    break;
3950
121
  case MethodListType::ClassMethods:
3951
121
    prefix = "OBJC_CLASS_METHODS_";
3952
121
    section = "__OBJC,__cls_meth,regular,no_dead_strip";
3953
121
    forProtocol = false;
3954
121
    break;
3955
15
  case MethodListType::ProtocolInstanceMethods:
3956
15
    prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3957
15
    section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3958
15
    forProtocol = true;
3959
15
    break;
3960
15
  case MethodListType::ProtocolClassMethods:
3961
15
    prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3962
15
    section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3963
15
    forProtocol = true;
3964
15
    break;
3965
15
  case MethodListType::OptionalProtocolInstanceMethods:
3966
15
    prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3967
15
    section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3968
15
    forProtocol = true;
3969
15
    break;
3970
15
  case MethodListType::OptionalProtocolClassMethods:
3971
15
    prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3972
15
    section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3973
15
    forProtocol = true;
3974
15
    break;
3975
316
  }
3976
3977
  // Return null for empty list.
3978
316
  if (methods.empty())
3979
212
    return llvm::Constant::getNullValue(forProtocol
3980
53
                                        ? ObjCTypes.MethodDescriptionListPtrTy
3981
159
                                        : ObjCTypes.MethodListPtrTy);
3982
3983
  // For protocols, this is an objc_method_description_list, which has
3984
  // a slightly different structure.
3985
104
  if (forProtocol) {
3986
7
    ConstantInitBuilder builder(CGM);
3987
7
    auto values = builder.beginStruct();
3988
7
    values.addInt(ObjCTypes.IntTy, methods.size());
3989
7
    auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3990
7
    for (auto MD : methods) {
3991
7
      emitMethodDescriptionConstant(methodArray, MD);
3992
7
    }
3993
7
    methodArray.finishAndAddTo(values);
3994
3995
7
    llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3996
7
                                                 CGM.getPointerAlign(), true);
3997
7
    return llvm::ConstantExpr::getBitCast(GV,
3998
7
                                          ObjCTypes.MethodDescriptionListPtrTy);
3999
7
  }
4000
4001
  // Otherwise, it's an objc_method_list.
4002
97
  ConstantInitBuilder builder(CGM);
4003
97
  auto values = builder.beginStruct();
4004
97
  values.addNullPointer(ObjCTypes.Int8PtrTy);
4005
97
  values.addInt(ObjCTypes.IntTy, methods.size());
4006
97
  auto methodArray = values.beginArray(ObjCTypes.MethodTy);
4007
202
  for (auto MD : methods) {
4008
202
    if (!MD->isDirectMethod())
4009
202
      emitMethodConstant(methodArray, MD);
4010
202
  }
4011
97
  methodArray.finishAndAddTo(values);
4012
4013
97
  llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
4014
97
                                               CGM.getPointerAlign(), true);
4015
97
  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
4016
97
}
4017
4018
llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
4019
2.52k
                                                const ObjCContainerDecl *CD) {
4020
2.52k
  llvm::Function *Method;
4021
4022
2.52k
  if (OMD->isDirectMethod()) {
4023
39
    Method = GenerateDirectMethod(OMD, CD);
4024
2.48k
  } else {
4025
2.48k
    auto Name = getSymbolNameForMethod(OMD);
4026
4027
2.48k
    CodeGenTypes &Types = CGM.getTypes();
4028
2.48k
    llvm::FunctionType *MethodTy =
4029
2.48k
        Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4030
2.48k
    Method =
4031
2.48k
        llvm::Function::Create(MethodTy, llvm::GlobalValue::InternalLinkage,
4032
2.48k
                               Name, &CGM.getModule());
4033
2.48k
  }
4034
4035
2.52k
  MethodDefinitions.insert(std::make_pair(OMD, Method));
4036
4037
2.52k
  return Method;
4038
2.52k
}
4039
4040
llvm::Function *
4041
CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD,
4042
106
                                      const ObjCContainerDecl *CD) {
4043
106
  auto *COMD = OMD->getCanonicalDecl();
4044
106
  auto I = DirectMethodDefinitions.find(COMD);
4045
106
  llvm::Function *OldFn = nullptr, *Fn = nullptr;
4046
4047
106
  if (I != DirectMethodDefinitions.end()) {
4048
    // Objective-C allows for the declaration and implementation types
4049
    // to differ slightly.
4050
    //
4051
    // If we're being asked for the Function associated for a method
4052
    // implementation, a previous value might have been cached
4053
    // based on the type of the canonical declaration.
4054
    //
4055
    // If these do not match, then we'll replace this function with
4056
    // a new one that has the proper type below.
4057
24
    if (!OMD->getBody() || 
COMD->getReturnType() == OMD->getReturnType()17
)
4058
23
      return I->second;
4059
1
    OldFn = I->second;
4060
1
  }
4061
4062
83
  CodeGenTypes &Types = CGM.getTypes();
4063
83
  llvm::FunctionType *MethodTy =
4064
83
    Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4065
4066
83
  if (OldFn) {
4067
1
    Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4068
1
                                "", &CGM.getModule());
4069
1
    Fn->takeName(OldFn);
4070
1
    OldFn->replaceAllUsesWith(
4071
1
        llvm::ConstantExpr::getBitCast(Fn, OldFn->getType()));
4072
1
    OldFn->eraseFromParent();
4073
4074
    // Replace the cached function in the map.
4075
1
    I->second = Fn;
4076
82
  } else {
4077
82
    auto Name = getSymbolNameForMethod(OMD, /*include category*/ false);
4078
4079
82
    Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4080
82
                                Name, &CGM.getModule());
4081
82
    DirectMethodDefinitions.insert(std::make_pair(COMD, Fn));
4082
82
  }
4083
4084
83
  return Fn;
4085
106
}
4086
4087
void CGObjCCommonMac::GenerateDirectMethodPrologue(
4088
    CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
4089
39
    const ObjCContainerDecl *CD) {
4090
39
  auto &Builder = CGF.Builder;
4091
39
  bool ReceiverCanBeNull = true;
4092
39
  auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
4093
39
  auto selfValue = Builder.CreateLoad(selfAddr);
4094
4095
  // Generate:
4096
  //
4097
  // /* for class methods only to force class lazy initialization */
4098
  // self = [self self];
4099
  //
4100
  // /* unless the receiver is never NULL */
4101
  // if (self == nil) {
4102
  //     return (ReturnType){ };
4103
  // }
4104
  //
4105
  // _cmd = @selector(...)
4106
  // ...
4107
4108
39
  if (OMD->isClassMethod()) {
4109
3
    const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
4110
3
    assert(OID &&
4111
3
           "GenerateDirectMethod() should be called with the Class Interface");
4112
3
    Selector SelfSel = GetNullarySelector("self", CGM.getContext());
4113
3
    auto ResultType = CGF.getContext().getObjCIdType();
4114
3
    RValue result;
4115
3
    CallArgList Args;
4116
4117
    // TODO: If this method is inlined, the caller might know that `self` is
4118
    // already initialized; for example, it might be an ordinary Objective-C
4119
    // method which always receives an initialized `self`, or it might have just
4120
    // forced initialization on its own.
4121
    //
4122
    // We should find a way to eliminate this unnecessary initialization in such
4123
    // cases in LLVM.
4124
3
    result = GeneratePossiblySpecializedMessageSend(
4125
3
        CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
4126
3
        nullptr, true);
4127
3
    Builder.CreateStore(result.getScalarVal(), selfAddr);
4128
4129
    // Nullable `Class` expressions cannot be messaged with a direct method
4130
    // so the only reason why the receive can be null would be because
4131
    // of weak linking.
4132
3
    ReceiverCanBeNull = isWeakLinkedClass(OID);
4133
3
  }
4134
4135
39
  if (ReceiverCanBeNull) {
4136
36
    llvm::BasicBlock *SelfIsNilBlock =
4137
36
        CGF.createBasicBlock("objc_direct_method.self_is_nil");
4138
36
    llvm::BasicBlock *ContBlock =
4139
36
        CGF.createBasicBlock("objc_direct_method.cont");
4140
4141
    // if (self == nil) {
4142
36
    auto selfTy = cast<llvm::PointerType>(selfValue->getType());
4143
36
    auto Zero = llvm::ConstantPointerNull::get(selfTy);
4144
4145
36
    llvm::MDBuilder MDHelper(CGM.getLLVMContext());
4146
36
    Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock,
4147
36
                         ContBlock, MDHelper.createBranchWeights(1, 1 << 20));
4148
4149
36
    CGF.EmitBlock(SelfIsNilBlock);
4150
4151
    //   return (ReturnType){ };
4152
36
    auto retTy = OMD->getReturnType();
4153
36
    Builder.SetInsertPoint(SelfIsNilBlock);
4154
36
    if (!retTy->isVoidType()) {
4155
32
      CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
4156
32
    }
4157
36
    CGF.EmitBranchThroughCleanup(CGF.ReturnBlock);
4158
    // }
4159
4160
    // rest of the body
4161
36
    CGF.EmitBlock(ContBlock);
4162
36
    Builder.SetInsertPoint(ContBlock);
4163
36
  }
4164
4165
  // only synthesize _cmd if it's referenced
4166
39
  if (OMD->getCmdDecl()->isUsed()) {
4167
0
    Builder.CreateStore(GetSelector(CGF, OMD),
4168
0
                        CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
4169
0
  }
4170
39
}
4171
4172
llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4173
                                               ConstantStructBuilder &Init,
4174
                                                         StringRef Section,
4175
                                                         CharUnits Align,
4176
873
                                                         bool AddToUsed) {
4177
873
  llvm::GlobalValue::LinkageTypes LT =
4178
873
      getLinkageTypeForObjCMetadata(CGM, Section);
4179
873
  llvm::GlobalVariable *GV =
4180
873
      Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT);
4181
873
  if (!Section.empty())
4182
860
    GV->setSection(Section);
4183
873
  if (AddToUsed)
4184
862
    CGM.addCompilerUsedGlobal(GV);
4185
873
  return GV;
4186
873
}
4187
4188
llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4189
                                                         llvm::Constant *Init,
4190
                                                         StringRef Section,
4191
                                                         CharUnits Align,
4192
211
                                                         bool AddToUsed) {
4193
211
  llvm::Type *Ty = Init->getType();
4194
211
  llvm::GlobalValue::LinkageTypes LT =
4195
211
      getLinkageTypeForObjCMetadata(CGM, Section);
4196
211
  llvm::GlobalVariable *GV =
4197
211
      new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name);
4198
211
  if (!Section.empty())
4199
203
    GV->setSection(Section);
4200
211
  GV->setAlignment(Align.getAsAlign());
4201
211
  if (AddToUsed)
4202
211
    CGM.addCompilerUsedGlobal(GV);
4203
211
  return GV;
4204
211
}
4205
4206
llvm::GlobalVariable *
4207
CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
4208
                                      bool ForceNonFragileABI,
4209
13.1k
                                      bool NullTerminate) {
4210
13.1k
  StringRef Label;
4211
13.1k
  switch (Type) {
4212
1.80k
  case ObjCLabelType::ClassName:     Label = "OBJC_CLASS_NAME_"; break;
4213
7.89k
  case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
4214
2.58k
  case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
4215
877
  case ObjCLabelType::PropertyName:  Label = "OBJC_PROP_NAME_ATTR_"; break;
4216
13.1k
  }
4217
4218
13.1k
  bool NonFragile = ForceNonFragileABI || 
isNonFragileABI()13.0k
;
4219
4220
13.1k
  StringRef Section;
4221
13.1k
  switch (Type) {
4222
1.80k
  case ObjCLabelType::ClassName:
4223
1.37k
    Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
4224
434
                         : "__TEXT,__cstring,cstring_literals";
4225
1.80k
    break;
4226
7.89k
  case ObjCLabelType::MethodVarName:
4227
7.48k
    Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4228
414
                         : "__TEXT,__cstring,cstring_literals";
4229
7.89k
    break;
4230
2.58k
  case ObjCLabelType::MethodVarType:
4231
2.34k
    Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
4232
240
                         : "__TEXT,__cstring,cstring_literals";
4233
2.58k
    break;
4234
877
  case ObjCLabelType::PropertyName:
4235
838
    Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4236
39
                         : "__TEXT,__cstring,cstring_literals";
4237
877
    break;
4238
13.1k
  }
4239
4240
13.1k
  llvm::Constant *Value =
4241
13.1k
      llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
4242
13.1k
  llvm::GlobalVariable *GV =
4243
13.1k
      new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
4244
13.1k
                               /*isConstant=*/true,
4245
13.1k
                               llvm::GlobalValue::PrivateLinkage, Value, Label);
4246
13.1k
  if (CGM.getTriple().isOSBinFormatMachO())
4247
12.8k
    GV->setSection(Section);
4248
13.1k
  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4249
13.1k
  GV->setAlignment(CharUnits::One().getAsAlign());
4250
13.1k
  CGM.addCompilerUsedGlobal(GV);
4251
4252
13.1k
  return GV;
4253
13.1k
}
4254
4255
167
llvm::Function *CGObjCMac::ModuleInitFunction() {
4256
  // Abuse this interface function as a place to finalize.
4257
167
  FinishModule();
4258
167
  return nullptr;
4259
167
}
4260
4261
0
llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() {
4262
0
  return ObjCTypes.getGetPropertyFn();
4263
0
}
4264
4265
0
llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() {
4266
0
  return ObjCTypes.getSetPropertyFn();
4267
0
}
4268
4269
llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4270
0
                                                                bool copy) {
4271
0
  return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4272
0
}
4273
4274
8
llvm::FunctionCallee CGObjCMac::GetGetStructFunction() {
4275
8
  return ObjCTypes.getCopyStructFn();
4276
8
}
4277
4278
8
llvm::FunctionCallee CGObjCMac::GetSetStructFunction() {
4279
8
  return ObjCTypes.getCopyStructFn();
4280
8
}
4281
4282
0
llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() {
4283
0
  return ObjCTypes.getCppAtomicObjectFunction();
4284
0
}
4285
4286
0
llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() {
4287
0
  return ObjCTypes.getCppAtomicObjectFunction();
4288
0
}
4289
4290
5
llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() {
4291
5
  return ObjCTypes.getEnumerationMutationFn();
4292
5
}
4293
4294
35
void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4295
35
  return EmitTryOrSynchronizedStmt(CGF, S);
4296
35
}
4297
4298
void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4299
6
                                     const ObjCAtSynchronizedStmt &S) {
4300
6
  return EmitTryOrSynchronizedStmt(CGF, S);
4301
6
}
4302
4303
namespace {
4304
  struct PerformFragileFinally final : EHScopeStack::Cleanup {
4305
    const Stmt &S;
4306
    Address SyncArgSlot;
4307
    Address CallTryExitVar;
4308
    Address ExceptionData;
4309
    ObjCTypesHelper &ObjCTypes;
4310
    PerformFragileFinally(const Stmt *S,
4311
                          Address SyncArgSlot,
4312
                          Address CallTryExitVar,
4313
                          Address ExceptionData,
4314
                          ObjCTypesHelper *ObjCTypes)
4315
      : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4316
41
        ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4317
4318
64
    void Emit(CodeGenFunction &CGF, Flags flags) override {
4319
      // Check whether we need to call objc_exception_try_exit.
4320
      // In optimized code, this branch will always be folded.
4321
64
      llvm::BasicBlock *FinallyCallExit =
4322
64
        CGF.createBasicBlock("finally.call_exit");
4323
64
      llvm::BasicBlock *FinallyNoCallExit =
4324
64
        CGF.createBasicBlock("finally.no_call_exit");
4325
64
      CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4326
64
                               FinallyCallExit, FinallyNoCallExit);
4327
4328
64
      CGF.EmitBlock(FinallyCallExit);
4329
64
      CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4330
64
                                  ExceptionData.getPointer());
4331
4332
64
      CGF.EmitBlock(FinallyNoCallExit);
4333
4334
64
      if (isa<ObjCAtTryStmt>(S)) {
4335
57
        if (const ObjCAtFinallyStmt* FinallyStmt =
4336
5
              cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4337
          // Don't try to do the @finally if this is an EH cleanup.
4338
5
          if (flags.isForEHCleanup()) 
return0
;
4339
4340
          // Save the current cleanup destination in case there's
4341
          // control flow inside the finally statement.
4342
5
          llvm::Value *CurCleanupDest =
4343
5
            CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4344
4345
5
          CGF.EmitStmt(FinallyStmt->getFinallyBody());
4346
4347
5
          if (CGF.HaveInsertPoint()) {
4348
4
            CGF.Builder.CreateStore(CurCleanupDest,
4349
4
                                    CGF.getNormalCleanupDestSlot());
4350
1
          } else {
4351
            // Currently, the end of the cleanup must always exist.
4352
1
            CGF.EnsureInsertPoint();
4353
1
          }
4354
5
        }
4355
7
      } else {
4356
        // Emit objc_sync_exit(expr); as finally's sole statement for
4357
        // @synchronized.
4358
7
        llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4359
7
        CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4360
7
      }
4361
64
    }
4362
  };
4363
4364
  class FragileHazards {
4365
    CodeGenFunction &CGF;
4366
    SmallVector<llvm::Value*, 20> Locals;
4367
    llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4368
4369
    llvm::InlineAsm *ReadHazard;
4370
    llvm::InlineAsm *WriteHazard;
4371
4372
    llvm::FunctionType *GetAsmFnType();
4373
4374
    void collectLocals();
4375
    void emitReadHazard(CGBuilderTy &Builder);
4376
4377
  public:
4378
    FragileHazards(CodeGenFunction &CGF);
4379
4380
    void emitWriteHazard();
4381
    void emitHazardsInNewBlocks();
4382
  };
4383
} // end anonymous namespace
4384
4385
/// Create the fragile-ABI read and write hazards based on the current
4386
/// state of the function, which is presumed to be immediately prior
4387
/// to a @try block.  These hazards are used to maintain correct
4388
/// semantics in the face of optimization and the fragile ABI's
4389
/// cavalier use of setjmp/longjmp.
4390
41
FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4391
41
  collectLocals();
4392
4393
41
  if (Locals.empty()) 
return0
;
4394
4395
  // Collect all the blocks in the function.
4396
41
  for (llvm::Function::iterator
4397
97
         I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; 
++I56
)
4398
56
    BlocksBeforeTry.insert(&*I);
4399
4400
41
  llvm::FunctionType *AsmFnTy = GetAsmFnType();
4401
4402
  // Create a read hazard for the allocas.  This inhibits dead-store
4403
  // optimizations and forces the values to memory.  This hazard is
4404
  // inserted before any 'throwing' calls in the protected scope to
4405
  // reflect the possibility that the variables might be read from the
4406
  // catch block if the call throws.
4407
41
  {
4408
41
    std::string Constraint;
4409
117
    for (unsigned I = 0, E = Locals.size(); I != E; 
++I76
) {
4410
76
      if (I) 
Constraint += ','35
;
4411
76
      Constraint += "*m";
4412
76
    }
4413
4414
41
    ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4415
41
  }
4416
4417
  // Create a write hazard for the allocas.  This inhibits folding
4418
  // loads across the hazard.  This hazard is inserted at the
4419
  // beginning of the catch path to reflect the possibility that the
4420
  // variables might have been written within the protected scope.
4421
41
  {
4422
41
    std::string Constraint;
4423
117
    for (unsigned I = 0, E = Locals.size(); I != E; 
++I76
) {
4424
76
      if (I) 
Constraint += ','35
;
4425
76
      Constraint += "=*m";
4426
76
    }
4427
4428
41
    WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4429
41
  }
4430
41
}
4431
4432
/// Emit a write hazard at the current location.
4433
41
void FragileHazards::emitWriteHazard() {
4434
41
  if (Locals.empty()) 
return0
;
4435
4436
41
  CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4437
41
}
4438
4439
55
void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4440
55
  assert(!Locals.empty());
4441
55
  llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4442
55
  call->setDoesNotThrow();
4443
55
  call->setCallingConv(CGF.getRuntimeCC());
4444
55
}
4445
4446
/// Emit read hazards in all the protected blocks, i.e. all the blocks
4447
/// which have been inserted since the beginning of the try.
4448
41
void FragileHazards::emitHazardsInNewBlocks() {
4449
41
  if (Locals.empty()) 
return0
;
4450
4451
41
  CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4452
4453
  // Iterate through all blocks, skipping those prior to the try.
4454
41
  for (llvm::Function::iterator
4455
284
         FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; 
++FI243
) {
4456
243
    llvm::BasicBlock &BB = *FI;
4457
243
    if (BlocksBeforeTry.count(&BB)) 
continue56
;
4458
4459
    // Walk through all the calls in the block.
4460
187
    for (llvm::BasicBlock::iterator
4461
894
           BI = BB.begin(), BE = BB.end(); BI != BE; 
++BI707
) {
4462
707
      llvm::Instruction &I = *BI;
4463
4464
      // Ignore instructions that aren't non-intrinsic calls.
4465
      // These are the only calls that can possibly call longjmp.
4466
707
      if (!isa<llvm::CallInst>(I) && 
!isa<llvm::InvokeInst>(I)568
)
4467
535
        continue;
4468
172
      if (isa<llvm::IntrinsicInst>(I))
4469
18
        continue;
4470
4471
      // Ignore call sites marked nounwind.  This may be questionable,
4472
      // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4473
154
      if (cast<llvm::CallBase>(I).doesNotThrow())
4474
99
        continue;
4475
4476
      // Insert a read hazard before the call.  This will ensure that
4477
      // any writes to the locals are performed before making the
4478
      // call.  If the call throws, then this is sufficient to
4479
      // guarantee correctness as long as it doesn't also write to any
4480
      // locals.
4481
55
      Builder.SetInsertPoint(&BB, BI);
4482
55
      emitReadHazard(Builder);
4483
55
    }
4484
187
  }
4485
41
}
4486
4487
82
static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4488
82
  if (V.isValid()) 
S.insert(V.getPointer())5
;
4489
82
}
4490
4491
41
void FragileHazards::collectLocals() {
4492
  // Compute a set of allocas to ignore.
4493
41
  llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4494
41
  addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4495
41
  addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4496
4497
  // Collect all the allocas currently in the function.  This is
4498
  // probably way too aggressive.
4499
41
  llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4500
41
  for (llvm::BasicBlock::iterator
4501
241
         I = Entry.begin(), E = Entry.end(); I != E; 
++I200
)
4502
200
    if (isa<llvm::AllocaInst>(*I) && 
!AllocasToIgnore.count(&*I)81
)
4503
76
      Locals.push_back(&*I);
4504
41
}
4505
4506
41
llvm::FunctionType *FragileHazards::GetAsmFnType() {
4507
41
  SmallVector<llvm::Type *, 16> tys(Locals.size());
4508
117
  for (unsigned i = 0, e = Locals.size(); i != e; 
++i76
)
4509
76
    tys[i] = Locals[i]->getType();
4510
41
  return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4511
41
}
4512
4513
/*
4514
4515
  Objective-C setjmp-longjmp (sjlj) Exception Handling
4516
  --
4517
4518
  A catch buffer is a setjmp buffer plus:
4519
    - a pointer to the exception that was caught
4520
    - a pointer to the previous exception data buffer
4521
    - two pointers of reserved storage
4522
  Therefore catch buffers form a stack, with a pointer to the top
4523
  of the stack kept in thread-local storage.
4524
4525
  objc_exception_try_enter pushes a catch buffer onto the EH stack.
4526
  objc_exception_try_exit pops the given catch buffer, which is
4527
    required to be the top of the EH stack.
4528
  objc_exception_throw pops the top of the EH stack, writes the
4529
    thrown exception into the appropriate field, and longjmps
4530
    to the setjmp buffer.  It crashes the process (with a printf
4531
    and an abort()) if there are no catch buffers on the stack.
4532
  objc_exception_extract just reads the exception pointer out of the
4533
    catch buffer.
4534
4535
  There's no reason an implementation couldn't use a light-weight
4536
  setjmp here --- something like __builtin_setjmp, but API-compatible
4537
  with the heavyweight setjmp.  This will be more important if we ever
4538
  want to implement correct ObjC/C++ exception interactions for the
4539
  fragile ABI.
4540
4541
  Note that for this use of setjmp/longjmp to be correct, we may need
4542
  to mark some local variables volatile: if a non-volatile local
4543
  variable is modified between the setjmp and the longjmp, it has
4544
  indeterminate value.  For the purposes of LLVM IR, it may be
4545
  sufficient to make loads and stores within the @try (to variables
4546
  declared outside the @try) volatile.  This is necessary for
4547
  optimized correctness, but is not currently being done; this is
4548
  being tracked as rdar://problem/8160285
4549
4550
  The basic framework for a @try-catch-finally is as follows:
4551
  {
4552
  objc_exception_data d;
4553
  id _rethrow = null;
4554
  bool _call_try_exit = true;
4555
4556
  objc_exception_try_enter(&d);
4557
  if (!setjmp(d.jmp_buf)) {
4558
  ... try body ...
4559
  } else {
4560
  // exception path
4561
  id _caught = objc_exception_extract(&d);
4562
4563
  // enter new try scope for handlers
4564
  if (!setjmp(d.jmp_buf)) {
4565
  ... match exception and execute catch blocks ...
4566
4567
  // fell off end, rethrow.
4568
  _rethrow = _caught;
4569
  ... jump-through-finally to finally_rethrow ...
4570
  } else {
4571
  // exception in catch block
4572
  _rethrow = objc_exception_extract(&d);
4573
  _call_try_exit = false;
4574
  ... jump-through-finally to finally_rethrow ...
4575
  }
4576
  }
4577
  ... jump-through-finally to finally_end ...
4578
4579
  finally:
4580
  if (_call_try_exit)
4581
  objc_exception_try_exit(&d);
4582
4583
  ... finally block ....
4584
  ... dispatch to finally destination ...
4585
4586
  finally_rethrow:
4587
  objc_exception_throw(_rethrow);
4588
4589
  finally_end:
4590
  }
4591
4592
  This framework differs slightly from the one gcc uses, in that gcc
4593
  uses _rethrow to determine if objc_exception_try_exit should be called
4594
  and if the object should be rethrown. This breaks in the face of
4595
  throwing nil and introduces unnecessary branches.
4596
4597
  We specialize this framework for a few particular circumstances:
4598
4599
  - If there are no catch blocks, then we avoid emitting the second
4600
  exception handling context.
4601
4602
  - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4603
  e)) we avoid emitting the code to rethrow an uncaught exception.
4604
4605
  - FIXME: If there is no @finally block we can do a few more
4606
  simplifications.
4607
4608
  Rethrows and Jumps-Through-Finally
4609
  --
4610
4611
  '@throw;' is supported by pushing the currently-caught exception
4612
  onto ObjCEHStack while the @catch blocks are emitted.
4613
4614
  Branches through the @finally block are handled with an ordinary
4615
  normal cleanup.  We do not register an EH cleanup; fragile-ABI ObjC
4616
  exceptions are not compatible with C++ exceptions, and this is
4617
  hardly the only place where this will go wrong.
4618
4619
  @synchronized(expr) { stmt; } is emitted as if it were:
4620
    id synch_value = expr;
4621
    objc_sync_enter(synch_value);
4622
    @try { stmt; } @finally { objc_sync_exit(synch_value); }
4623
*/
4624
4625
void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4626
41
                                          const Stmt &S) {
4627
41
  bool isTry = isa<ObjCAtTryStmt>(S);
4628
4629
  // A destination for the fall-through edges of the catch handlers to
4630
  // jump to.
4631
41
  CodeGenFunction::JumpDest FinallyEnd =
4632
41
    CGF.getJumpDestInCurrentScope("finally.end");
4633
4634
  // A destination for the rethrow edge of the catch handlers to jump
4635
  // to.
4636
41
  CodeGenFunction::JumpDest FinallyRethrow =
4637
41
    CGF.getJumpDestInCurrentScope("finally.rethrow");
4638
4639
  // For @synchronized, call objc_sync_enter(sync.expr). The
4640
  // evaluation of the expression must occur before we enter the
4641
  // @synchronized.  We can't avoid a temp here because we need the
4642
  // value to be preserved.  If the backend ever does liveness
4643
  // correctly after setjmp, this will be unnecessary.
4644
41
  Address SyncArgSlot = Address::invalid();
4645
41
  if (!isTry) {
4646
6
    llvm::Value *SyncArg =
4647
6
      CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4648
6
    SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4649
6
    CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4650
4651
6
    SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4652
6
                                       CGF.getPointerAlign(), "sync.arg");
4653
6
    CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4654
6
  }
4655
4656
  // Allocate memory for the setjmp buffer.  This needs to be kept
4657
  // live throughout the try and catch blocks.
4658
41
  Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4659
41
                                               CGF.getPointerAlign(),
4660
41
                                               "exceptiondata.ptr");
4661
4662
  // Create the fragile hazards.  Note that this will not capture any
4663
  // of the allocas required for exception processing, but will
4664
  // capture the current basic block (which extends all the way to the
4665
  // setjmp call) as "before the @try".
4666
41
  FragileHazards Hazards(CGF);
4667
4668
  // Create a flag indicating whether the cleanup needs to call
4669
  // objc_exception_try_exit.  This is true except when
4670
  //   - no catches match and we're branching through the cleanup
4671
  //     just to rethrow the exception, or
4672
  //   - a catch matched and we're falling out of the catch handler.
4673
  // The setjmp-safety rule here is that we should always store to this
4674
  // variable in a place that dominates the branch through the cleanup
4675
  // without passing through any setjmps.
4676
41
  Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4677
41
                                                CharUnits::One(),
4678
41
                                                "_call_try_exit");
4679
4680
  // A slot containing the exception to rethrow.  Only needed when we
4681
  // have both a @catch and a @finally.
4682
41
  Address PropagatingExnVar = Address::invalid();
4683
4684
  // Push a normal cleanup to leave the try scope.
4685
41
  CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4686
41
                                                 SyncArgSlot,
4687
41
                                                 CallTryExitVar,
4688
41
                                                 ExceptionData,
4689
41
                                                 &ObjCTypes);
4690
4691
  // Enter a try block:
4692
  //  - Call objc_exception_try_enter to push ExceptionData on top of
4693
  //    the EH stack.
4694
41
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4695
41
                              ExceptionData.getPointer());
4696
4697
  //  - Call setjmp on the exception data buffer.
4698
41
  llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4699
41
  llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4700
41
  llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4701
41
      ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4702
41
      "setjmp_buffer");
4703
41
  llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4704
41
      ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4705
41
  SetJmpResult->setCanReturnTwice();
4706
4707
  // If setjmp returned 0, enter the protected block; otherwise,
4708
  // branch to the handler.
4709
41
  llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4710
41
  llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4711
41
  llvm::Value *DidCatch =
4712
41
    CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4713
41
  CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4714
4715
  // Emit the protected block.
4716
41
  CGF.EmitBlock(TryBlock);
4717
41
  CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4718
35
  CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4719
6
                     : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4720
4721
41
  CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4722
4723
  // Emit the exception handler block.
4724
41
  CGF.EmitBlock(TryHandler);
4725
4726
  // Don't optimize loads of the in-scope locals across this point.
4727
41
  Hazards.emitWriteHazard();
4728
4729
  // For a @synchronized (or a @try with no catches), just branch
4730
  // through the cleanup to the rethrow block.
4731
41
  if (!isTry || 
!cast<ObjCAtTryStmt>(S).getNumCatchStmts()35
) {
4732
    // Tell the cleanup not to re-pop the exit.
4733
10
    CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4734
10
    CGF.EmitBranchThroughCleanup(FinallyRethrow);
4735
4736
  // Otherwise, we have to match against the caught exceptions.
4737
31
  } else {
4738
    // Retrieve the exception object.  We may emit multiple blocks but
4739
    // nothing can cross this so the value is already in SSA form.
4740
31
    llvm::CallInst *Caught =
4741
31
      CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4742
31
                                  ExceptionData.getPointer(), "caught");
4743
4744
    // Push the exception to rethrow onto the EH value stack for the
4745
    // benefit of any @throws in the handlers.
4746
31
    CGF.ObjCEHValueStack.push_back(Caught);
4747
4748
31
    const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4749
4750
31
    bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4751
4752
31
    llvm::BasicBlock *CatchBlock = nullptr;
4753
31
    llvm::BasicBlock *CatchHandler = nullptr;
4754
31
    if (HasFinally) {
4755
      // Save the currently-propagating exception before
4756
      // objc_exception_try_enter clears the exception slot.
4757
1
      PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4758
1
                                               CGF.getPointerAlign(),
4759
1
                                               "propagating_exception");
4760
1
      CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4761
4762
      // Enter a new exception try block (in case a @catch block
4763
      // throws an exception).
4764
1
      CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4765
1
                                  ExceptionData.getPointer());
4766
4767
1
      llvm::CallInst *SetJmpResult =
4768
1
        CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4769
1
                                    SetJmpBuffer, "setjmp.result");
4770
1
      SetJmpResult->setCanReturnTwice();
4771
4772
1
      llvm::Value *Threw =
4773
1
        CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4774
4775
1
      CatchBlock = CGF.createBasicBlock("catch");
4776
1
      CatchHandler = CGF.createBasicBlock("catch_for_catch");
4777
1
      CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4778
4779
1
      CGF.EmitBlock(CatchBlock);
4780
1
    }
4781
4782
31
    CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4783
4784
    // Handle catch list. As a special case we check if everything is
4785
    // matched and avoid generating code for falling off the end if
4786
    // so.
4787
31
    bool AllMatched = false;
4788
40
    for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; 
++I9
) {
4789
33
      const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4790
4791
33
      const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4792
33
      const ObjCObjectPointerType *OPT = nullptr;
4793
4794
      // catch(...) always matches.
4795
33
      if (!CatchParam) {
4796
8
        AllMatched = true;
4797
25
      } else {
4798
25
        OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4799
4800
        // catch(id e) always matches under this ABI, since only
4801
        // ObjC exceptions end up here in the first place.
4802
        // FIXME: For the time being we also match id<X>; this should
4803
        // be rejected by Sema instead.
4804
25
        if (OPT && (OPT->isObjCIdType() || 
OPT->isObjCQualifiedIdType()9
))
4805
16
          AllMatched = true;
4806
25
      }
4807
4808
      // If this is a catch-all, we don't need to test anything.
4809
33
      if (AllMatched) {
4810
24
        CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4811
4812
24
        if (CatchParam) {
4813
16
          CGF.EmitAutoVarDecl(*CatchParam);
4814
16
          assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4815
4816
          // These types work out because ConvertType(id) == i8*.
4817
16
          EmitInitOfCatchParam(CGF, Caught, CatchParam);
4818
16
        }
4819
4820
24
        CGF.EmitStmt(CatchStmt->getCatchBody());
4821
4822
        // The scope of the catch variable ends right here.
4823
24
        CatchVarCleanups.ForceCleanup();
4824
4825
24
        CGF.EmitBranchThroughCleanup(FinallyEnd);
4826
24
        break;
4827
24
      }
4828
4829
9
      assert(OPT && "Unexpected non-object pointer type in @catch");
4830
9
      const ObjCObjectType *ObjTy = OPT->getObjectType();
4831
4832
      // FIXME: @catch (Class c) ?
4833
9
      ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4834
9
      assert(IDecl && "Catch parameter must have Objective-C type!");
4835
4836
      // Check if the @catch block matches the exception object.
4837
9
      llvm::Value *Class = EmitClassRef(CGF, IDecl);
4838
4839
9
      llvm::Value *matchArgs[] = { Class, Caught };
4840
9
      llvm::CallInst *Match =
4841
9
        CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4842
9
                                    matchArgs, "match");
4843
4844
9
      llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4845
9
      llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4846
4847
9
      CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4848
9
                               MatchedBlock, NextCatchBlock);
4849
4850
      // Emit the @catch block.
4851
9
      CGF.EmitBlock(MatchedBlock);
4852
4853
      // Collect any cleanups for the catch variable.  The scope lasts until
4854
      // the end of the catch body.
4855
9
      CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4856
4857
9
      CGF.EmitAutoVarDecl(*CatchParam);
4858
9
      assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4859
4860
      // Initialize the catch variable.
4861
9
      llvm::Value *Tmp =
4862
9
        CGF.Builder.CreateBitCast(Caught,
4863
9
                                  CGF.ConvertType(CatchParam->getType()));
4864
9
      EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4865
4866
9
      CGF.EmitStmt(CatchStmt->getCatchBody());
4867
4868
      // We're done with the catch variable.
4869
9
      CatchVarCleanups.ForceCleanup();
4870
4871
9
      CGF.EmitBranchThroughCleanup(FinallyEnd);
4872
4873
9
      CGF.EmitBlock(NextCatchBlock);
4874
9
    }
4875
4876
31
    CGF.ObjCEHValueStack.pop_back();
4877
4878
    // If nothing wanted anything to do with the caught exception,
4879
    // kill the extract call.
4880
31
    if (Caught->use_empty())
4881
8
      Caught->eraseFromParent();
4882
4883
31
    if (!AllMatched)
4884
7
      CGF.EmitBranchThroughCleanup(FinallyRethrow);
4885
4886
31
    if (HasFinally) {
4887
      // Emit the exception handler for the @catch blocks.
4888
1
      CGF.EmitBlock(CatchHandler);
4889
4890
      // In theory we might now need a write hazard, but actually it's
4891
      // unnecessary because there's no local-accessing code between
4892
      // the try's write hazard and here.
4893
      //Hazards.emitWriteHazard();
4894
4895
      // Extract the new exception and save it to the
4896
      // propagating-exception slot.
4897
1
      assert(PropagatingExnVar.isValid());
4898
1
      llvm::CallInst *NewCaught =
4899
1
        CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4900
1
                                    ExceptionData.getPointer(), "caught");
4901
1
      CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4902
4903
      // Don't pop the catch handler; the throw already did.
4904
1
      CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4905
1
      CGF.EmitBranchThroughCleanup(FinallyRethrow);
4906
1
    }
4907
31
  }
4908
4909
  // Insert read hazards as required in the new blocks.
4910
41
  Hazards.emitHazardsInNewBlocks();
4911
4912
  // Pop the cleanup.
4913
41
  CGF.Builder.restoreIP(TryFallthroughIP);
4914
41
  if (CGF.HaveInsertPoint())
4915
36
    CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4916
41
  CGF.PopCleanupBlock();
4917
41
  CGF.EmitBlock(FinallyEnd.getBlock(), true);
4918
4919
  // Emit the rethrow block.
4920
41
  CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4921
41
  CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4922
41
  if (CGF.HaveInsertPoint()) {
4923
    // If we have a propagating-exception variable, check it.
4924
17
    llvm::Value *PropagatingExn;
4925
17
    if (PropagatingExnVar.isValid()) {
4926
1
      PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4927
4928
    // Otherwise, just look in the buffer for the exception to throw.
4929
16
    } else {
4930
16
      llvm::CallInst *Caught =
4931
16
        CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4932
16
                                    ExceptionData.getPointer());
4933
16
      PropagatingExn = Caught;
4934
16
    }
4935
4936
17
    CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4937
17
                                PropagatingExn);
4938
17
    CGF.Builder.CreateUnreachable();
4939
17
  }
4940
4941
41
  CGF.Builder.restoreIP(SavedIP);
4942
41
}
4943
4944
void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4945
                              const ObjCAtThrowStmt &S,
4946
3
                              bool ClearInsertionPoint) {
4947
3
  llvm::Value *ExceptionAsObject;
4948
4949
3
  if (const Expr *ThrowExpr = S.getThrowExpr()) {
4950
2
    llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4951
2
    ExceptionAsObject =
4952
2
      CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4953
1
  } else {
4954
1
    assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4955
1
           "Unexpected rethrow outside @catch block.");
4956
1
    ExceptionAsObject = CGF.ObjCEHValueStack.back();
4957
1
  }
4958
4959
3
  CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4960
3
    ->setDoesNotReturn();
4961
3
  CGF.Builder.CreateUnreachable();
4962
4963
  // Clear the insertion point to indicate we are in unreachable code.
4964
3
  if (ClearInsertionPoint)
4965
3
    CGF.Builder.ClearInsertionPoint();
4966
3
}
4967
4968
/// EmitObjCWeakRead - Code gen for loading value of a __weak
4969
/// object: objc_read_weak (id *src)
4970
///
4971
llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4972
33
                                          Address AddrWeakObj) {
4973
33
  llvm::Type* DestTy = AddrWeakObj.getElementType();
4974
33
  AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4975
33
                                          ObjCTypes.PtrObjectPtrTy);
4976
33
  llvm::Value *read_weak =
4977
33
    CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4978
33
                                AddrWeakObj.getPointer(), "weakread");
4979
33
  read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4980
33
  return read_weak;
4981
33
}
4982
4983
/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4984
/// objc_assign_weak (id src, id *dst)
4985
///
4986
void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4987
22
                                   llvm::Value *src, Address dst) {
4988
22
  llvm::Type * SrcTy = src->getType();
4989
22
  if (!isa<llvm::PointerType>(SrcTy)) {
4990
0
    unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4991
0
    assert(Size <= 8 && "does not support size > 8");
4992
0
    src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4993
0
                      : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4994
0
    src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4995
0
  }
4996
22
  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4997
22
  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4998
22
  llvm::Value *args[] = { src, dst.getPointer() };
4999
22
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
5000
22
                              args, "weakassign");
5001
22
}
5002
5003
/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
5004
/// objc_assign_global (id src, id *dst)
5005
///
5006
void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
5007
                                     llvm::Value *src, Address dst,
5008
84
                                     bool threadlocal) {
5009
84
  llvm::Type * SrcTy = src->getType();
5010
84
  if (!isa<llvm::PointerType>(SrcTy)) {
5011
0
    unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5012
0
    assert(Size <= 8 && "does not support size > 8");
5013
0
    src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5014
0
                      : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5015
0
    src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5016
0
  }
5017
84
  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5018
84
  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5019
84
  llvm::Value *args[] = { src, dst.getPointer() };
5020
84
  if (!threadlocal)
5021
84
    CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
5022
84
                                args, "globalassign");
5023
0
  else
5024
0
    CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
5025
0
                                args, "threadlocalassign");
5026
84
}
5027
5028
/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
5029
/// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
5030
///
5031
void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
5032
                                   llvm::Value *src, Address dst,
5033
43
                                   llvm::Value *ivarOffset) {
5034
43
  assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
5035
43
  llvm::Type * SrcTy = src->getType();
5036
43
  if (!isa<llvm::PointerType>(SrcTy)) {
5037
0
    unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5038
0
    assert(Size <= 8 && "does not support size > 8");
5039
0
    src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5040
0
                      : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5041
0
    src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5042
0
  }
5043
43
  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5044
43
  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5045
43
  llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
5046
43
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
5047
43
}
5048
5049
/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5050
/// objc_assign_strongCast (id src, id *dst)
5051
///
5052
void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
5053
66
                                         llvm::Value *src, Address dst) {
5054
66
  llvm::Type * SrcTy = src->getType();
5055
66
  if (!isa<llvm::PointerType>(SrcTy)) {
5056
0
    unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5057
0
    assert(Size <= 8 && "does not support size > 8");
5058
0
    src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5059
0
                      : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5060
0
    src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5061
0
  }
5062
66
  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5063
66
  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5064
66
  llvm::Value *args[] = { src, dst.getPointer() };
5065
66
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
5066
66
                              args, "strongassign");
5067
66
}
5068
5069
void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
5070
                                         Address DestPtr,
5071
                                         Address SrcPtr,
5072
27
                                         llvm::Value *size) {
5073
27
  SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
5074
27
  DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
5075
27
  llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
5076
27
  CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
5077
27
}
5078
5079
/// EmitObjCValueForIvar - Code Gen for ivar reference.
5080
///
5081
LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
5082
                                       QualType ObjectTy,
5083
                                       llvm::Value *BaseValue,
5084
                                       const ObjCIvarDecl *Ivar,
5085
279
                                       unsigned CVRQualifiers) {
5086
279
  const ObjCInterfaceDecl *ID =
5087
279
    ObjectTy->castAs<ObjCObjectType>()->getInterface();
5088
279
  return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
5089
279
                                  EmitIvarOffset(CGF, ID, Ivar));
5090
279
}
5091
5092
llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
5093
                                       const ObjCInterfaceDecl *Interface,
5094
279
                                       const ObjCIvarDecl *Ivar) {
5095
279
  uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
5096
279
  return llvm::ConstantInt::get(
5097
279
    CGM.getTypes().ConvertType(CGM.getContext().LongTy),
5098
279
    Offset);
5099
279
}
5100
5101
/* *** Private Interface *** */
5102
5103
std::string CGObjCCommonMac::GetSectionName(StringRef Section,
5104
81.6k
                                            StringRef MachOAttributes) {
5105
81.6k
  switch (CGM.getTriple().getObjectFormat()) {
5106
0
  case llvm::Triple::UnknownObjectFormat:
5107
0
    llvm_unreachable("unexpected object file format");
5108
81.0k
  case llvm::Triple::MachO: {
5109
81.0k
    if (MachOAttributes.empty())
5110
0
      return ("__DATA," + Section).str();
5111
81.0k
    return ("__DATA," + Section + "," + MachOAttributes).str();
5112
81.0k
  }
5113
248
  case llvm::Triple::ELF:
5114
248
    assert(Section.substr(0, 2) == "__" &&
5115
248
           "expected the name to begin with __");
5116
248
    return Section.substr(2).str();
5117
313
  case llvm::Triple::COFF:
5118
313
    assert(Section.substr(0, 2) == "__" &&
5119
313
           "expected the name to begin with __");
5120
313
    return ("." + Section.substr(2) + "$B").str();
5121
0
  case llvm::Triple::Wasm:
5122
0
  case llvm::Triple::GOFF:
5123
0
  case llvm::Triple::XCOFF:
5124
0
    llvm::report_fatal_error(
5125
0
        "Objective-C support is unimplemented for object file format");
5126
0
  }
5127
5128
0
  llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum");
5129
0
}
5130
5131
/// EmitImageInfo - Emit the image info marker used to encode some module
5132
/// level information.
5133
///
5134
/// See: <rdr://4810609&4810587&4810587>
5135
/// struct IMAGE_INFO {
5136
///   unsigned version;
5137
///   unsigned flags;
5138
/// };
5139
enum ImageInfoFlags {
5140
  eImageInfo_FixAndContinue      = (1 << 0), // This flag is no longer set by clang.
5141
  eImageInfo_GarbageCollected    = (1 << 1),
5142
  eImageInfo_GCOnly              = (1 << 2),
5143
  eImageInfo_OptimizedByDyld     = (1 << 3), // This flag is set by the dyld shared cache.
5144
5145
  // A flag indicating that the module has no instances of a @synthesize of a
5146
  // superclass variable. <rdar://problem/6803242>
5147
  eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
5148
  eImageInfo_ImageIsSimulated    = (1 << 5),
5149
  eImageInfo_ClassProperties     = (1 << 6)
5150
};
5151
5152
12.4k
void CGObjCCommonMac::EmitImageInfo() {
5153
12.4k
  unsigned version = 0; // Version is unused?
5154
12.4k
  std::string Section =
5155
12.4k
      (ObjCABI == 1)
5156
167
          ? "__OBJC,__image_info,regular"
5157
12.3k
          : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
5158
5159
  // Generate module-level named metadata to convey this information to the
5160
  // linker and code-gen.
5161
12.4k
  llvm::Module &Mod = CGM.getModule();
5162
5163
  // Add the ObjC ABI version to the module flags.
5164
12.4k
  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
5165
12.4k
  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
5166
12.4k
                    version);
5167
12.4k
  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
5168
12.4k
                    llvm::MDString::get(VMContext, Section));
5169
5170
12.4k
  auto Int8Ty = llvm::Type::getInt8Ty(VMContext);
5171
12.4k
  if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5172
    // Non-GC overrides those files which specify GC.
5173
12.3k
    Mod.addModuleFlag(llvm::Module::Error,
5174
12.3k
                      "Objective-C Garbage Collection",
5175
12.3k
                      llvm::ConstantInt::get(Int8Ty,0));
5176
70
  } else {
5177
    // Add the ObjC garbage collection value.
5178
70
    Mod.addModuleFlag(llvm::Module::Error,
5179
70
                      "Objective-C Garbage Collection",
5180
70
                      llvm::ConstantInt::get(Int8Ty,
5181
70
                        (uint8_t)eImageInfo_GarbageCollected));
5182
5183
70
    if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
5184
      // Add the ObjC GC Only value.
5185
3
      Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
5186
3
                        eImageInfo_GCOnly);
5187
5188
      // Require that GC be specified and set to eImageInfo_GarbageCollected.
5189
3
      llvm::Metadata *Ops[2] = {
5190
3
          llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
5191
3
          llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
5192
3
              Int8Ty, eImageInfo_GarbageCollected))};
5193
3
      Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
5194
3
                        llvm::MDNode::get(VMContext, Ops));
5195
3
    }
5196
70
  }
5197
5198
  // Indicate whether we're compiling this to run on a simulator.
5199
12.4k
  if (CGM.getTarget().getTriple().isSimulatorEnvironment())
5200
2
    Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
5201
2
                      eImageInfo_ImageIsSimulated);
5202
5203
  // Indicate whether we are generating class properties.
5204
12.4k
  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
5205
12.4k
                    eImageInfo_ClassProperties);
5206
12.4k
}
5207
5208
// struct objc_module {
5209
//   unsigned long version;
5210
//   unsigned long size;
5211
//   const char *name;
5212
//   Symtab symtab;
5213
// };
5214
5215
// FIXME: Get from somewhere
5216
static const int ModuleVersion = 7;
5217
5218
167
void CGObjCMac::EmitModuleInfo() {
5219
167
  uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
5220
5221
167
  ConstantInitBuilder builder(CGM);
5222
167
  auto values = builder.beginStruct(ObjCTypes.ModuleTy);
5223
167
  values.addInt(ObjCTypes.LongTy, ModuleVersion);
5224
167
  values.addInt(ObjCTypes.LongTy, Size);
5225
  // This used to be the filename, now it is unused. <rdr://4327263>
5226
167
  values.add(GetClassName(StringRef("")));
5227