Coverage Report

Created: 2021-09-21 08:58

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