Coverage Report

Created: 2022-01-18 06:27

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