Coverage Report

Created: 2020-02-25 14:32

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