Coverage Report

Created: 2019-07-24 05:18

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