Coverage Report

Created: 2020-09-19 12:23

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