clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGObjCMac.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCMac.cpp
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | #include "CGBlocks.h" |
14 | #include "CGCleanup.h" |
15 | #include "CGObjCRuntime.h" |
16 | #include "CGRecordLayout.h" |
17 | #include "CodeGenFunction.h" |
18 | #include "CodeGenModule.h" |
19 | #include "clang/AST/ASTContext.h" |
20 | #include "clang/AST/Attr.h" |
21 | #include "clang/AST/Decl.h" |
22 | #include "clang/AST/DeclObjC.h" |
23 | #include "clang/AST/Mangle.h" |
24 | #include "clang/AST/RecordLayout.h" |
25 | #include "clang/AST/StmtObjC.h" |
26 | #include "clang/Basic/CodeGenOptions.h" |
27 | #include "clang/Basic/LangOptions.h" |
28 | #include "clang/CodeGen/CGFunctionInfo.h" |
29 | #include "clang/CodeGen/ConstantInitBuilder.h" |
30 | #include "llvm/ADT/CachedHashString.h" |
31 | #include "llvm/ADT/DenseSet.h" |
32 | #include "llvm/ADT/SetVector.h" |
33 | #include "llvm/ADT/SmallPtrSet.h" |
34 | #include "llvm/ADT/SmallString.h" |
35 | #include "llvm/ADT/UniqueVector.h" |
36 | #include "llvm/IR/DataLayout.h" |
37 | #include "llvm/IR/InlineAsm.h" |
38 | #include "llvm/IR/IntrinsicInst.h" |
39 | #include "llvm/IR/LLVMContext.h" |
40 | #include "llvm/IR/Module.h" |
41 | #include "llvm/Support/ScopedPrinter.h" |
42 | #include "llvm/Support/raw_ostream.h" |
43 | #include <cstdio> |
44 | |
45 | using namespace clang; |
46 | using namespace CodeGen; |
47 | |
48 | namespace { |
49 | |
50 | |
51 | |
52 | |
53 | class ObjCCommonTypesHelper { |
54 | protected: |
55 | llvm::LLVMContext &VMContext; |
56 | |
57 | private: |
58 | |
59 | |
60 | |
61 | |
62 | |
63 | |
64 | |
65 | llvm::FunctionCallee getMessageSendFn() const { |
66 | |
67 | |
68 | llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
69 | return CGM.CreateRuntimeFunction( |
70 | llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend", |
71 | llvm::AttributeList::get(CGM.getLLVMContext(), |
72 | llvm::AttributeList::FunctionIndex, |
73 | llvm::Attribute::NonLazyBind)); |
74 | } |
75 | |
76 | |
77 | |
78 | |
79 | |
80 | |
81 | llvm::FunctionCallee getMessageSendStretFn() const { |
82 | llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
83 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, |
84 | params, true), |
85 | "objc_msgSend_stret"); |
86 | } |
87 | |
88 | |
89 | |
90 | |
91 | |
92 | |
93 | llvm::FunctionCallee getMessageSendFpretFn() const { |
94 | llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
95 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy, |
96 | params, true), |
97 | "objc_msgSend_fpret"); |
98 | } |
99 | |
100 | |
101 | |
102 | |
103 | |
104 | |
105 | llvm::FunctionCallee getMessageSendFp2retFn() const { |
106 | llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
107 | llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext); |
108 | llvm::Type *resultType = |
109 | llvm::StructType::get(longDoubleType, longDoubleType); |
110 | |
111 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType, |
112 | params, true), |
113 | "objc_msgSend_fp2ret"); |
114 | } |
115 | |
116 | |
117 | |
118 | |
119 | |
120 | |
121 | llvm::FunctionCallee getMessageSendSuperFn() const { |
122 | llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy }; |
123 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
124 | params, true), |
125 | "objc_msgSendSuper"); |
126 | } |
127 | |
128 | |
129 | |
130 | |
131 | |
132 | llvm::FunctionCallee getMessageSendSuperFn2() const { |
133 | llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy }; |
134 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
135 | params, true), |
136 | "objc_msgSendSuper2"); |
137 | } |
138 | |
139 | |
140 | |
141 | |
142 | |
143 | llvm::FunctionCallee getMessageSendSuperStretFn() const { |
144 | llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy }; |
145 | return CGM.CreateRuntimeFunction( |
146 | llvm::FunctionType::get(CGM.VoidTy, params, true), |
147 | "objc_msgSendSuper_stret"); |
148 | } |
149 | |
150 | |
151 | |
152 | |
153 | |
154 | llvm::FunctionCallee getMessageSendSuperStretFn2() const { |
155 | llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy }; |
156 | return CGM.CreateRuntimeFunction( |
157 | llvm::FunctionType::get(CGM.VoidTy, params, true), |
158 | "objc_msgSendSuper2_stret"); |
159 | } |
160 | |
161 | llvm::FunctionCallee getMessageSendSuperFpretFn() const { |
162 | |
163 | return getMessageSendSuperFn(); |
164 | } |
165 | |
166 | llvm::FunctionCallee getMessageSendSuperFpretFn2() const { |
167 | |
168 | return getMessageSendSuperFn2(); |
169 | } |
170 | |
171 | protected: |
172 | CodeGen::CodeGenModule &CGM; |
173 | |
174 | public: |
175 | llvm::IntegerType *ShortTy, *IntTy, *LongTy; |
176 | llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy; |
177 | llvm::Type *IvarOffsetVarTy; |
178 | |
179 | |
180 | llvm::PointerType *ObjectPtrTy; |
181 | |
182 | |
183 | llvm::PointerType *PtrObjectPtrTy; |
184 | |
185 | |
186 | llvm::PointerType *SelectorPtrTy; |
187 | |
188 | private: |
189 | |
190 | |
191 | llvm::Type *ExternalProtocolPtrTy; |
192 | |
193 | public: |
194 | llvm::Type *getExternalProtocolPtrTy() { |
195 | if (!ExternalProtocolPtrTy) { |
196 | |
197 | |
198 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
199 | ASTContext &Ctx = CGM.getContext(); |
200 | llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType()); |
201 | ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T); |
202 | } |
203 | |
204 | return ExternalProtocolPtrTy; |
205 | } |
206 | |
207 | |
208 | QualType SuperCTy; |
209 | |
210 | QualType SuperPtrCTy; |
211 | |
212 | |
213 | llvm::StructType *SuperTy; |
214 | |
215 | llvm::PointerType *SuperPtrTy; |
216 | |
217 | |
218 | |
219 | llvm::StructType *PropertyTy; |
220 | |
221 | |
222 | |
223 | llvm::StructType *PropertyListTy; |
224 | |
225 | llvm::PointerType *PropertyListPtrTy; |
226 | |
227 | |
228 | llvm::StructType *MethodTy; |
229 | |
230 | |
231 | llvm::Type *CacheTy; |
232 | |
233 | llvm::PointerType *CachePtrTy; |
234 | |
235 | llvm::FunctionCallee getGetPropertyFn() { |
236 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
237 | ASTContext &Ctx = CGM.getContext(); |
238 | |
239 | CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); |
240 | CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); |
241 | CanQualType Params[] = { |
242 | IdType, SelType, |
243 | Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy}; |
244 | llvm::FunctionType *FTy = |
245 | Types.GetFunctionType( |
246 | Types.arrangeBuiltinFunctionDeclaration(IdType, Params)); |
247 | return CGM.CreateRuntimeFunction(FTy, "objc_getProperty"); |
248 | } |
249 | |
250 | llvm::FunctionCallee getSetPropertyFn() { |
251 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
252 | ASTContext &Ctx = CGM.getContext(); |
253 | |
254 | CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); |
255 | CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); |
256 | CanQualType Params[] = { |
257 | IdType, |
258 | SelType, |
259 | Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), |
260 | IdType, |
261 | Ctx.BoolTy, |
262 | Ctx.BoolTy}; |
263 | llvm::FunctionType *FTy = |
264 | Types.GetFunctionType( |
265 | Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
266 | return CGM.CreateRuntimeFunction(FTy, "objc_setProperty"); |
267 | } |
268 | |
269 | llvm::FunctionCallee getOptimizedSetPropertyFn(bool atomic, bool copy) { |
270 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
271 | ASTContext &Ctx = CGM.getContext(); |
272 | |
273 | |
274 | |
275 | |
276 | |
277 | |
278 | |
279 | |
280 | |
281 | SmallVector<CanQualType,4> Params; |
282 | CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); |
283 | CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); |
284 | Params.push_back(IdType); |
285 | Params.push_back(SelType); |
286 | Params.push_back(IdType); |
287 | Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified()); |
288 | llvm::FunctionType *FTy = |
289 | Types.GetFunctionType( |
290 | Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
291 | const char *name; |
292 | if (atomic && copy) |
293 | name = "objc_setProperty_atomic_copy"; |
294 | else if (atomic && !copy) |
295 | name = "objc_setProperty_atomic"; |
296 | else if (!atomic && copy) |
297 | name = "objc_setProperty_nonatomic_copy"; |
298 | else |
299 | name = "objc_setProperty_nonatomic"; |
300 | |
301 | return CGM.CreateRuntimeFunction(FTy, name); |
302 | } |
303 | |
304 | llvm::FunctionCallee getCopyStructFn() { |
305 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
306 | ASTContext &Ctx = CGM.getContext(); |
307 | |
308 | SmallVector<CanQualType,5> Params; |
309 | Params.push_back(Ctx.VoidPtrTy); |
310 | Params.push_back(Ctx.VoidPtrTy); |
311 | Params.push_back(Ctx.getSizeType()); |
312 | Params.push_back(Ctx.BoolTy); |
313 | Params.push_back(Ctx.BoolTy); |
314 | llvm::FunctionType *FTy = |
315 | Types.GetFunctionType( |
316 | Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
317 | return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct"); |
318 | } |
319 | |
320 | |
321 | |
322 | |
323 | |
324 | llvm::FunctionCallee getCppAtomicObjectFunction() { |
325 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
326 | ASTContext &Ctx = CGM.getContext(); |
327 | |
328 | SmallVector<CanQualType,3> Params; |
329 | Params.push_back(Ctx.VoidPtrTy); |
330 | Params.push_back(Ctx.VoidPtrTy); |
331 | Params.push_back(Ctx.VoidPtrTy); |
332 | llvm::FunctionType *FTy = |
333 | Types.GetFunctionType( |
334 | Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
335 | return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic"); |
336 | } |
337 | |
338 | llvm::FunctionCallee getEnumerationMutationFn() { |
339 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
340 | ASTContext &Ctx = CGM.getContext(); |
341 | |
342 | SmallVector<CanQualType,1> Params; |
343 | Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType())); |
344 | llvm::FunctionType *FTy = |
345 | Types.GetFunctionType( |
346 | Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
347 | return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation"); |
348 | } |
349 | |
350 | llvm::FunctionCallee getLookUpClassFn() { |
351 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
352 | ASTContext &Ctx = CGM.getContext(); |
353 | |
354 | SmallVector<CanQualType,1> Params; |
355 | Params.push_back( |
356 | Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst()))); |
357 | llvm::FunctionType *FTy = |
358 | Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration( |
359 | Ctx.getCanonicalType(Ctx.getObjCClassType()), |
360 | Params)); |
361 | return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass"); |
362 | } |
363 | |
364 | |
365 | llvm::FunctionCallee getGcReadWeakFn() { |
366 | |
367 | llvm::Type *args[] = { ObjectPtrTy->getPointerTo() }; |
368 | llvm::FunctionType *FTy = |
369 | llvm::FunctionType::get(ObjectPtrTy, args, false); |
370 | return CGM.CreateRuntimeFunction(FTy, "objc_read_weak"); |
371 | } |
372 | |
373 | |
374 | llvm::FunctionCallee getGcAssignWeakFn() { |
375 | |
376 | llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; |
377 | llvm::FunctionType *FTy = |
378 | llvm::FunctionType::get(ObjectPtrTy, args, false); |
379 | return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak"); |
380 | } |
381 | |
382 | |
383 | llvm::FunctionCallee getGcAssignGlobalFn() { |
384 | |
385 | llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; |
386 | llvm::FunctionType *FTy = |
387 | llvm::FunctionType::get(ObjectPtrTy, args, false); |
388 | return CGM.CreateRuntimeFunction(FTy, "objc_assign_global"); |
389 | } |
390 | |
391 | |
392 | llvm::FunctionCallee getGcAssignThreadLocalFn() { |
393 | |
394 | llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; |
395 | llvm::FunctionType *FTy = |
396 | llvm::FunctionType::get(ObjectPtrTy, args, false); |
397 | return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal"); |
398 | } |
399 | |
400 | |
401 | llvm::FunctionCallee getGcAssignIvarFn() { |
402 | |
403 | llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(), |
404 | CGM.PtrDiffTy }; |
405 | llvm::FunctionType *FTy = |
406 | llvm::FunctionType::get(ObjectPtrTy, args, false); |
407 | return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar"); |
408 | } |
409 | |
410 | |
411 | llvm::FunctionCallee GcMemmoveCollectableFn() { |
412 | |
413 | llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy }; |
414 | llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false); |
415 | return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable"); |
416 | } |
417 | |
418 | |
419 | llvm::FunctionCallee getGcAssignStrongCastFn() { |
420 | |
421 | llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; |
422 | llvm::FunctionType *FTy = |
423 | llvm::FunctionType::get(ObjectPtrTy, args, false); |
424 | return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast"); |
425 | } |
426 | |
427 | |
428 | llvm::FunctionCallee getExceptionThrowFn() { |
429 | |
430 | llvm::Type *args[] = { ObjectPtrTy }; |
431 | llvm::FunctionType *FTy = |
432 | llvm::FunctionType::get(CGM.VoidTy, args, false); |
433 | return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw"); |
434 | } |
435 | |
436 | |
437 | llvm::FunctionCallee getExceptionRethrowFn() { |
438 | |
439 | llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false); |
440 | return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow"); |
441 | } |
442 | |
443 | |
444 | llvm::FunctionCallee getSyncEnterFn() { |
445 | |
446 | llvm::Type *args[] = { ObjectPtrTy }; |
447 | llvm::FunctionType *FTy = |
448 | llvm::FunctionType::get(CGM.IntTy, args, false); |
449 | return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter"); |
450 | } |
451 | |
452 | |
453 | llvm::FunctionCallee getSyncExitFn() { |
454 | |
455 | llvm::Type *args[] = { ObjectPtrTy }; |
456 | llvm::FunctionType *FTy = |
457 | llvm::FunctionType::get(CGM.IntTy, args, false); |
458 | return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit"); |
459 | } |
460 | |
461 | llvm::FunctionCallee getSendFn(bool IsSuper) const { |
462 | return IsSuper ? getMessageSendSuperFn() : getMessageSendFn(); |
463 | } |
464 | |
465 | llvm::FunctionCallee getSendFn2(bool IsSuper) const { |
466 | return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn(); |
467 | } |
468 | |
469 | llvm::FunctionCallee getSendStretFn(bool IsSuper) const { |
470 | return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn(); |
471 | } |
472 | |
473 | llvm::FunctionCallee getSendStretFn2(bool IsSuper) const { |
474 | return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn(); |
475 | } |
476 | |
477 | llvm::FunctionCallee getSendFpretFn(bool IsSuper) const { |
478 | return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn(); |
479 | } |
480 | |
481 | llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const { |
482 | return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn(); |
483 | } |
484 | |
485 | llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const { |
486 | return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn(); |
487 | } |
488 | |
489 | llvm::FunctionCallee getSendFp2RetFn2(bool IsSuper) const { |
490 | return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn(); |
491 | } |
492 | |
493 | ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm); |
494 | }; |
495 | |
496 | |
497 | |
498 | class ObjCTypesHelper : public ObjCCommonTypesHelper { |
499 | public: |
500 | |
501 | llvm::StructType *SymtabTy; |
502 | |
503 | llvm::PointerType *SymtabPtrTy; |
504 | |
505 | llvm::StructType *ModuleTy; |
506 | |
507 | |
508 | llvm::StructType *ProtocolTy; |
509 | |
510 | llvm::PointerType *ProtocolPtrTy; |
511 | |
512 | |
513 | llvm::StructType *ProtocolExtensionTy; |
514 | |
515 | |
516 | llvm::PointerType *ProtocolExtensionPtrTy; |
517 | |
518 | |
519 | llvm::StructType *MethodDescriptionTy; |
520 | |
521 | |
522 | llvm::StructType *MethodDescriptionListTy; |
523 | |
524 | |
525 | llvm::PointerType *MethodDescriptionListPtrTy; |
526 | |
527 | llvm::StructType *ProtocolListTy; |
528 | |
529 | llvm::PointerType *ProtocolListPtrTy; |
530 | |
531 | llvm::StructType *CategoryTy; |
532 | |
533 | llvm::StructType *ClassTy; |
534 | |
535 | llvm::PointerType *ClassPtrTy; |
536 | |
537 | llvm::StructType *ClassExtensionTy; |
538 | |
539 | llvm::PointerType *ClassExtensionPtrTy; |
540 | |
541 | llvm::StructType *IvarTy; |
542 | |
543 | llvm::StructType *IvarListTy; |
544 | |
545 | llvm::PointerType *IvarListPtrTy; |
546 | |
547 | llvm::StructType *MethodListTy; |
548 | |
549 | llvm::PointerType *MethodListPtrTy; |
550 | |
551 | |
552 | llvm::StructType *ExceptionDataTy; |
553 | |
554 | |
555 | llvm::FunctionCallee getExceptionTryEnterFn() { |
556 | llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; |
557 | return CGM.CreateRuntimeFunction( |
558 | llvm::FunctionType::get(CGM.VoidTy, params, false), |
559 | "objc_exception_try_enter"); |
560 | } |
561 | |
562 | |
563 | llvm::FunctionCallee getExceptionTryExitFn() { |
564 | llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; |
565 | return CGM.CreateRuntimeFunction( |
566 | llvm::FunctionType::get(CGM.VoidTy, params, false), |
567 | "objc_exception_try_exit"); |
568 | } |
569 | |
570 | |
571 | llvm::FunctionCallee getExceptionExtractFn() { |
572 | llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; |
573 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
574 | params, false), |
575 | "objc_exception_extract"); |
576 | } |
577 | |
578 | |
579 | llvm::FunctionCallee getExceptionMatchFn() { |
580 | llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy }; |
581 | return CGM.CreateRuntimeFunction( |
582 | llvm::FunctionType::get(CGM.Int32Ty, params, false), |
583 | "objc_exception_match"); |
584 | } |
585 | |
586 | |
587 | llvm::FunctionCallee getSetJmpFn() { |
588 | |
589 | llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() }; |
590 | return CGM.CreateRuntimeFunction( |
591 | llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp", |
592 | llvm::AttributeList::get(CGM.getLLVMContext(), |
593 | llvm::AttributeList::FunctionIndex, |
594 | llvm::Attribute::NonLazyBind)); |
595 | } |
596 | |
597 | public: |
598 | ObjCTypesHelper(CodeGen::CodeGenModule &cgm); |
599 | }; |
600 | |
601 | |
602 | |
603 | class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper { |
604 | public: |
605 | |
606 | llvm::StructType *MethodListnfABITy; |
607 | |
608 | |
609 | llvm::PointerType *MethodListnfABIPtrTy; |
610 | |
611 | |
612 | llvm::StructType *ProtocolnfABITy; |
613 | |
614 | |
615 | llvm::PointerType *ProtocolnfABIPtrTy; |
616 | |
617 | |
618 | llvm::StructType *ProtocolListnfABITy; |
619 | |
620 | |
621 | llvm::PointerType *ProtocolListnfABIPtrTy; |
622 | |
623 | |
624 | llvm::StructType *ClassnfABITy; |
625 | |
626 | |
627 | llvm::PointerType *ClassnfABIPtrTy; |
628 | |
629 | |
630 | llvm::StructType *IvarnfABITy; |
631 | |
632 | |
633 | llvm::StructType *IvarListnfABITy; |
634 | |
635 | |
636 | llvm::PointerType *IvarListnfABIPtrTy; |
637 | |
638 | |
639 | llvm::StructType *ClassRonfABITy; |
640 | |
641 | |
642 | llvm::PointerType *ImpnfABITy; |
643 | |
644 | |
645 | llvm::StructType *CategorynfABITy; |
646 | |
647 | |
648 | |
649 | |
650 | |
651 | |
652 | |
653 | |
654 | llvm::StructType *MessageRefTy; |
655 | |
656 | QualType MessageRefCTy; |
657 | |
658 | |
659 | llvm::Type *MessageRefPtrTy; |
660 | |
661 | QualType MessageRefCPtrTy; |
662 | |
663 | |
664 | |
665 | |
666 | |
667 | |
668 | llvm::StructType *SuperMessageRefTy; |
669 | |
670 | |
671 | llvm::PointerType *SuperMessageRefPtrTy; |
672 | |
673 | llvm::FunctionCallee getMessageSendFixupFn() { |
674 | |
675 | llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; |
676 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
677 | params, true), |
678 | "objc_msgSend_fixup"); |
679 | } |
680 | |
681 | llvm::FunctionCallee getMessageSendFpretFixupFn() { |
682 | |
683 | llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; |
684 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
685 | params, true), |
686 | "objc_msgSend_fpret_fixup"); |
687 | } |
688 | |
689 | llvm::FunctionCallee getMessageSendStretFixupFn() { |
690 | |
691 | llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; |
692 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
693 | params, true), |
694 | "objc_msgSend_stret_fixup"); |
695 | } |
696 | |
697 | llvm::FunctionCallee getMessageSendSuper2FixupFn() { |
698 | |
699 | |
700 | llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy }; |
701 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
702 | params, true), |
703 | "objc_msgSendSuper2_fixup"); |
704 | } |
705 | |
706 | llvm::FunctionCallee getMessageSendSuper2StretFixupFn() { |
707 | |
708 | |
709 | llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy }; |
710 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
711 | params, true), |
712 | "objc_msgSendSuper2_stret_fixup"); |
713 | } |
714 | |
715 | llvm::FunctionCallee getObjCEndCatchFn() { |
716 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false), |
717 | "objc_end_catch"); |
718 | } |
719 | |
720 | llvm::FunctionCallee getObjCBeginCatchFn() { |
721 | llvm::Type *params[] = { Int8PtrTy }; |
722 | return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy, |
723 | params, false), |
724 | "objc_begin_catch"); |
725 | } |
726 | |
727 | |
728 | |
729 | |
730 | |
731 | |
732 | llvm::FunctionCallee getLoadClassrefFn() const { |
733 | |
734 | |
735 | |
736 | |
737 | |
738 | llvm::Type *params[] = { Int8PtrPtrTy }; |
739 | llvm::FunctionCallee F = CGM.CreateRuntimeFunction( |
740 | llvm::FunctionType::get(ClassnfABIPtrTy, params, false), |
741 | "objc_loadClassref", |
742 | llvm::AttributeList::get(CGM.getLLVMContext(), |
743 | llvm::AttributeList::FunctionIndex, |
744 | {llvm::Attribute::NonLazyBind, |
745 | llvm::Attribute::ReadNone, |
746 | llvm::Attribute::NoUnwind})); |
747 | if (!CGM.getTriple().isOSBinFormatCOFF()) |
748 | cast<llvm::Function>(F.getCallee())->setLinkage( |
749 | llvm::Function::ExternalWeakLinkage); |
750 | |
751 | return F; |
752 | } |
753 | |
754 | llvm::StructType *EHTypeTy; |
755 | llvm::Type *EHTypePtrTy; |
756 | |
757 | ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm); |
758 | }; |
759 | |
760 | enum class ObjCLabelType { |
761 | ClassName, |
762 | MethodVarName, |
763 | MethodVarType, |
764 | PropertyName, |
765 | }; |
766 | |
767 | class CGObjCCommonMac : public CodeGen::CGObjCRuntime { |
768 | public: |
769 | class SKIP_SCAN { |
770 | public: |
771 | unsigned skip; |
772 | unsigned scan; |
773 | SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0) |
774 | : skip(_skip), scan(_scan) {} |
775 | }; |
776 | |
777 | |
778 | |
779 | |
780 | |
781 | enum BLOCK_LAYOUT_OPCODE { |
782 | |
783 | |
784 | |
785 | |
786 | |
787 | |
788 | BLOCK_LAYOUT_OPERATOR = 0, |
789 | |
790 | |
791 | |
792 | |
793 | |
794 | BLOCK_LAYOUT_NON_OBJECT_BYTES = 1, |
795 | |
796 | |
797 | |
798 | |
799 | BLOCK_LAYOUT_NON_OBJECT_WORDS = 2, |
800 | |
801 | |
802 | |
803 | BLOCK_LAYOUT_STRONG = 3, |
804 | |
805 | |
806 | BLOCK_LAYOUT_BYREF = 4, |
807 | |
808 | |
809 | |
810 | BLOCK_LAYOUT_WEAK = 5, |
811 | |
812 | |
813 | |
814 | BLOCK_LAYOUT_UNRETAINED = 6 |
815 | |
816 | |
817 | |
818 | |
819 | |
820 | |
821 | |
822 | |
823 | |
824 | |
825 | |
826 | |
827 | }; |
828 | |
829 | class RUN_SKIP { |
830 | public: |
831 | enum BLOCK_LAYOUT_OPCODE opcode; |
832 | CharUnits block_var_bytepos; |
833 | CharUnits block_var_size; |
834 | RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR, |
835 | CharUnits BytePos = CharUnits::Zero(), |
836 | CharUnits Size = CharUnits::Zero()) |
837 | : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {} |
838 | |
839 | |
840 | bool operator<(const RUN_SKIP &b) const { |
841 | return block_var_bytepos < b.block_var_bytepos; |
842 | } |
843 | }; |
844 | |
845 | protected: |
846 | llvm::LLVMContext &VMContext; |
847 | |
848 | unsigned ObjCABI; |
849 | |
850 | |
851 | SmallVector<RUN_SKIP, 16> RunSkipBlockVars; |
852 | |
853 | |
854 | |
855 | llvm::SetVector<IdentifierInfo*> LazySymbols; |
856 | |
857 | |
858 | |
859 | |
860 | |
861 | llvm::SetVector<IdentifierInfo*> DefinedSymbols; |
862 | |
863 | |
864 | llvm::StringMap<llvm::GlobalVariable*> ClassNames; |
865 | |
866 | |
867 | llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames; |
868 | |
869 | |
870 | llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames; |
871 | |
872 | |
873 | |
874 | llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes; |
875 | |
876 | |
877 | |
878 | llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions; |
879 | |
880 | |
881 | |
882 | llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> DirectMethodDefinitions; |
883 | |
884 | |
885 | llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames; |
886 | |
887 | |
888 | llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences; |
889 | |
890 | |
891 | llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences; |
892 | |
893 | |
894 | |
895 | |
896 | llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols; |
897 | |
898 | |
899 | |
900 | llvm::DenseSet<IdentifierInfo*> DefinedProtocols; |
901 | |
902 | |
903 | SmallVector<llvm::GlobalValue*, 16> DefinedClasses; |
904 | |
905 | |
906 | SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses; |
907 | |
908 | |
909 | SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses; |
910 | |
911 | |
912 | SmallVector<llvm::GlobalValue*, 16> DefinedCategories; |
913 | |
914 | |
915 | SmallVector<llvm::GlobalValue*, 16> DefinedStubCategories; |
916 | |
917 | |
918 | SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories; |
919 | |
920 | |
921 | |
922 | llvm::WeakTrackingVH ConstantStringClassRef; |
923 | |
924 | |
925 | llvm::StructType *NSConstantStringType = nullptr; |
926 | |
927 | llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap; |
928 | |
929 | |
930 | |
931 | llvm::Constant *GetMethodVarName(Selector Sel); |
932 | llvm::Constant *GetMethodVarName(IdentifierInfo *Ident); |
933 | |
934 | |
935 | |
936 | |
937 | |
938 | llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D, |
939 | bool Extended = false); |
940 | llvm::Constant *GetMethodVarType(const FieldDecl *D); |
941 | |
942 | |
943 | |
944 | llvm::Constant *GetPropertyName(IdentifierInfo *Ident); |
945 | |
946 | |
947 | llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD, |
948 | const Decl *Container); |
949 | |
950 | |
951 | |
952 | |
953 | llvm::Constant *GetClassName(StringRef RuntimeName); |
954 | |
955 | llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD); |
956 | |
957 | |
958 | |
959 | |
960 | |
961 | |
962 | |
963 | |
964 | llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI, |
965 | CharUnits beginOffset, |
966 | CharUnits endOffset, |
967 | bool forStrongLayout, |
968 | bool hasMRCWeakIvars); |
969 | |
970 | llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI, |
971 | CharUnits beginOffset, |
972 | CharUnits endOffset) { |
973 | return BuildIvarLayout(OI, beginOffset, endOffset, true, false); |
974 | } |
975 | |
976 | llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI, |
977 | CharUnits beginOffset, |
978 | CharUnits endOffset, |
979 | bool hasMRCWeakIvars) { |
980 | return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars); |
981 | } |
982 | |
983 | Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout); |
984 | |
985 | void UpdateRunSkipBlockVars(bool IsByref, |
986 | Qualifiers::ObjCLifetime LifeTime, |
987 | CharUnits FieldOffset, |
988 | CharUnits FieldSize); |
989 | |
990 | void BuildRCBlockVarRecordLayout(const RecordType *RT, |
991 | CharUnits BytePos, bool &HasUnion, |
992 | bool ByrefLayout=false); |
993 | |
994 | void BuildRCRecordLayout(const llvm::StructLayout *RecLayout, |
995 | const RecordDecl *RD, |
996 | ArrayRef<const FieldDecl*> RecFields, |
997 | CharUnits BytePos, bool &HasUnion, |
998 | bool ByrefLayout); |
999 | |
1000 | uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout); |
1001 | |
1002 | llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout); |
1003 | |
1004 | |
1005 | |
1006 | llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident, |
1007 | const ObjCCommonTypesHelper &ObjCTypes); |
1008 | |
1009 | |
1010 | |
1011 | llvm::Constant *EmitPropertyList(Twine Name, |
1012 | const Decl *Container, |
1013 | const ObjCContainerDecl *OCD, |
1014 | const ObjCCommonTypesHelper &ObjCTypes, |
1015 | bool IsClassProperty); |
1016 | |
1017 | |
1018 | |
1019 | llvm::Constant *EmitProtocolMethodTypes(Twine Name, |
1020 | ArrayRef<llvm::Constant*> MethodTypes, |
1021 | const ObjCCommonTypesHelper &ObjCTypes); |
1022 | |
1023 | |
1024 | |
1025 | |
1026 | llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD); |
1027 | |
1028 | |
1029 | |
1030 | llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF, |
1031 | const ObjCInterfaceDecl *ID, |
1032 | ObjCCommonTypesHelper &ObjCTypes); |
1033 | |
1034 | std::string GetSectionName(StringRef Section, StringRef MachOAttributes); |
1035 | |
1036 | public: |
1037 | |
1038 | |
1039 | |
1040 | |
1041 | |
1042 | |
1043 | |
1044 | |
1045 | |
1046 | |
1047 | |
1048 | |
1049 | |
1050 | |
1051 | llvm::GlobalVariable *CreateMetadataVar(Twine Name, |
1052 | ConstantStructBuilder &Init, |
1053 | StringRef Section, CharUnits Align, |
1054 | bool AddToUsed); |
1055 | llvm::GlobalVariable *CreateMetadataVar(Twine Name, |
1056 | llvm::Constant *Init, |
1057 | StringRef Section, CharUnits Align, |
1058 | bool AddToUsed); |
1059 | |
1060 | llvm::GlobalVariable *CreateCStringLiteral(StringRef Name, |
1061 | ObjCLabelType LabelType, |
1062 | bool ForceNonFragileABI = false, |
1063 | bool NullTerminate = true); |
1064 | |
1065 | protected: |
1066 | CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF, |
1067 | ReturnValueSlot Return, |
1068 | QualType ResultType, |
1069 | Selector Sel, |
1070 | llvm::Value *Arg0, |
1071 | QualType Arg0Ty, |
1072 | bool IsSuper, |
1073 | const CallArgList &CallArgs, |
1074 | const ObjCMethodDecl *OMD, |
1075 | const ObjCInterfaceDecl *ClassReceiver, |
1076 | const ObjCCommonTypesHelper &ObjCTypes); |
1077 | |
1078 | |
1079 | |
1080 | void EmitImageInfo(); |
1081 | |
1082 | public: |
1083 | CGObjCCommonMac(CodeGen::CodeGenModule &cgm) |
1084 | : CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) {} |
1085 | |
1086 | bool isNonFragileABI() const { |
1087 | return ObjCABI == 2; |
1088 | } |
1089 | |
1090 | ConstantAddress GenerateConstantString(const StringLiteral *SL) override; |
1091 | ConstantAddress GenerateConstantNSString(const StringLiteral *SL); |
1092 | |
1093 | llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, |
1094 | const ObjCContainerDecl *CD=nullptr) override; |
1095 | |
1096 | llvm::Function *GenerateDirectMethod(const ObjCMethodDecl *OMD, |
1097 | const ObjCContainerDecl *CD); |
1098 | |
1099 | void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn, |
1100 | const ObjCMethodDecl *OMD, |
1101 | const ObjCContainerDecl *CD) override; |
1102 | |
1103 | void GenerateProtocol(const ObjCProtocolDecl *PD) override; |
1104 | |
1105 | |
1106 | |
1107 | |
1108 | |
1109 | virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0; |
1110 | |
1111 | virtual llvm::Constant *getNSConstantStringClassRef() = 0; |
1112 | |
1113 | llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, |
1114 | const CGBlockInfo &blockInfo) override; |
1115 | llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, |
1116 | const CGBlockInfo &blockInfo) override; |
1117 | std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM, |
1118 | const CGBlockInfo &blockInfo) override; |
1119 | |
1120 | llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM, |
1121 | QualType T) override; |
1122 | |
1123 | private: |
1124 | void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo); |
1125 | }; |
1126 | |
1127 | namespace { |
1128 | |
1129 | enum class MethodListType { |
1130 | CategoryInstanceMethods, |
1131 | CategoryClassMethods, |
1132 | InstanceMethods, |
1133 | ClassMethods, |
1134 | ProtocolInstanceMethods, |
1135 | ProtocolClassMethods, |
1136 | OptionalProtocolInstanceMethods, |
1137 | OptionalProtocolClassMethods, |
1138 | }; |
1139 | |
1140 | |
1141 | |
1142 | class ProtocolMethodLists { |
1143 | public: |
1144 | enum Kind { |
1145 | RequiredInstanceMethods, |
1146 | RequiredClassMethods, |
1147 | OptionalInstanceMethods, |
1148 | OptionalClassMethods |
1149 | }; |
1150 | enum { |
1151 | NumProtocolMethodLists = 4 |
1152 | }; |
1153 | |
1154 | static MethodListType getMethodListKind(Kind kind) { |
1155 | switch (kind) { |
1156 | case RequiredInstanceMethods: |
1157 | return MethodListType::ProtocolInstanceMethods; |
1158 | case RequiredClassMethods: |
1159 | return MethodListType::ProtocolClassMethods; |
1160 | case OptionalInstanceMethods: |
1161 | return MethodListType::OptionalProtocolInstanceMethods; |
1162 | case OptionalClassMethods: |
1163 | return MethodListType::OptionalProtocolClassMethods; |
1164 | } |
1165 | llvm_unreachable("bad kind"); |
1166 | } |
1167 | |
1168 | SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists]; |
1169 | |
1170 | static ProtocolMethodLists get(const ObjCProtocolDecl *PD) { |
1171 | ProtocolMethodLists result; |
1172 | |
1173 | for (auto MD : PD->methods()) { |
1174 | size_t index = (2 * size_t(MD->isOptional())) |
1175 | + (size_t(MD->isClassMethod())); |
1176 | result.Methods[index].push_back(MD); |
1177 | } |
1178 | |
1179 | return result; |
1180 | } |
1181 | |
1182 | template <class Self> |
1183 | SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const { |
1184 | |
1185 | |
1186 | |
1187 | |
1188 | |
1189 | |
1190 | SmallVector<llvm::Constant*, 8> result; |
1191 | |
1192 | |
1193 | for (auto &list : Methods) { |
1194 | for (auto MD : list) { |
1195 | result.push_back(self->GetMethodVarType(MD, true)); |
1196 | } |
1197 | } |
1198 | |
1199 | return result; |
1200 | } |
1201 | |
1202 | template <class Self> |
1203 | llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD, |
1204 | Kind kind) const { |
1205 | return self->emitMethodList(PD->getObjCRuntimeNameAsString(), |
1206 | getMethodListKind(kind), Methods[kind]); |
1207 | } |
1208 | }; |
1209 | |
1210 | } |
1211 | |
1212 | class CGObjCMac : public CGObjCCommonMac { |
1213 | private: |
1214 | friend ProtocolMethodLists; |
1215 | |
1216 | ObjCTypesHelper ObjCTypes; |
1217 | |
1218 | |
1219 | |
1220 | void EmitModuleInfo(); |
1221 | |
1222 | |
1223 | |
1224 | llvm::Constant *EmitModuleSymbols(); |
1225 | |
1226 | |
1227 | |
1228 | void FinishModule(); |
1229 | |
1230 | |
1231 | |
1232 | |
1233 | llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID, |
1234 | CharUnits instanceSize, |
1235 | bool hasMRCWeakIvars, |
1236 | bool isMetaclass); |
1237 | |
1238 | |
1239 | |
1240 | llvm::Value *EmitClassRef(CodeGenFunction &CGF, |
1241 | const ObjCInterfaceDecl *ID); |
1242 | |
1243 | llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF, |
1244 | IdentifierInfo *II); |
1245 | |
1246 | llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; |
1247 | |
1248 | |
1249 | llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID); |
1250 | |
1251 | |
1252 | |
1253 | |
1254 | |
1255 | |
1256 | llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID, |
1257 | bool ForClass); |
1258 | |
1259 | |
1260 | |
1261 | |
1262 | llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID); |
1263 | |
1264 | |
1265 | |
1266 | llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID, |
1267 | llvm::Constant *Protocols, |
1268 | ArrayRef<const ObjCMethodDecl *> Methods); |
1269 | |
1270 | void emitMethodConstant(ConstantArrayBuilder &builder, |
1271 | const ObjCMethodDecl *MD); |
1272 | |
1273 | void emitMethodDescriptionConstant(ConstantArrayBuilder &builder, |
1274 | const ObjCMethodDecl *MD); |
1275 | |
1276 | |
1277 | |
1278 | llvm::Constant *emitMethodList(Twine Name, MethodListType MLT, |
1279 | ArrayRef<const ObjCMethodDecl *> Methods); |
1280 | |
1281 | |
1282 | |
1283 | |
1284 | llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override; |
1285 | |
1286 | |
1287 | |
1288 | |
1289 | |
1290 | llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override; |
1291 | |
1292 | |
1293 | |
1294 | |
1295 | |
1296 | llvm::Constant * |
1297 | EmitProtocolExtension(const ObjCProtocolDecl *PD, |
1298 | const ProtocolMethodLists &methodLists); |
1299 | |
1300 | |
1301 | |
1302 | llvm::Constant *EmitProtocolList(Twine Name, |
1303 | ObjCProtocolDecl::protocol_iterator begin, |
1304 | ObjCProtocolDecl::protocol_iterator end); |
1305 | |
1306 | |
1307 | |
1308 | llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel); |
1309 | Address EmitSelectorAddr(Selector Sel); |
1310 | |
1311 | public: |
1312 | CGObjCMac(CodeGen::CodeGenModule &cgm); |
1313 | |
1314 | llvm::Constant *getNSConstantStringClassRef() override; |
1315 | |
1316 | llvm::Function *ModuleInitFunction() override; |
1317 | |
1318 | CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, |
1319 | ReturnValueSlot Return, |
1320 | QualType ResultType, |
1321 | Selector Sel, llvm::Value *Receiver, |
1322 | const CallArgList &CallArgs, |
1323 | const ObjCInterfaceDecl *Class, |
1324 | const ObjCMethodDecl *Method) override; |
1325 | |
1326 | CodeGen::RValue |
1327 | GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, |
1328 | ReturnValueSlot Return, QualType ResultType, |
1329 | Selector Sel, const ObjCInterfaceDecl *Class, |
1330 | bool isCategoryImpl, llvm::Value *Receiver, |
1331 | bool IsClassMessage, const CallArgList &CallArgs, |
1332 | const ObjCMethodDecl *Method) override; |
1333 | |
1334 | llvm::Value *GetClass(CodeGenFunction &CGF, |
1335 | const ObjCInterfaceDecl *ID) override; |
1336 | |
1337 | llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override; |
1338 | Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override; |
1339 | |
1340 | |
1341 | |
1342 | llvm::Value *GetSelector(CodeGenFunction &CGF, |
1343 | const ObjCMethodDecl *Method) override; |
1344 | |
1345 | llvm::Constant *GetEHType(QualType T) override; |
1346 | |
1347 | void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; |
1348 | |
1349 | void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; |
1350 | |
1351 | void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {} |
1352 | |
1353 | llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, |
1354 | const ObjCProtocolDecl *PD) override; |
1355 | |
1356 | llvm::FunctionCallee GetPropertyGetFunction() override; |
1357 | llvm::FunctionCallee GetPropertySetFunction() override; |
1358 | llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, |
1359 | bool copy) override; |
1360 | llvm::FunctionCallee GetGetStructFunction() override; |
1361 | llvm::FunctionCallee GetSetStructFunction() override; |
1362 | llvm::FunctionCallee GetCppAtomicObjectGetFunction() override; |
1363 | llvm::FunctionCallee GetCppAtomicObjectSetFunction() override; |
1364 | llvm::FunctionCallee EnumerationMutationFunction() override; |
1365 | |
1366 | void EmitTryStmt(CodeGen::CodeGenFunction &CGF, |
1367 | const ObjCAtTryStmt &S) override; |
1368 | void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, |
1369 | const ObjCAtSynchronizedStmt &S) override; |
1370 | void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S); |
1371 | void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, |
1372 | bool ClearInsertionPoint=true) override; |
1373 | llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, |
1374 | Address AddrWeakObj) override; |
1375 | void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, |
1376 | llvm::Value *src, Address dst) override; |
1377 | void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, |
1378 | llvm::Value *src, Address dest, |
1379 | bool threadlocal = false) override; |
1380 | void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, |
1381 | llvm::Value *src, Address dest, |
1382 | llvm::Value *ivarOffset) override; |
1383 | void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, |
1384 | llvm::Value *src, Address dest) override; |
1385 | void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, |
1386 | Address dest, Address src, |
1387 | llvm::Value *size) override; |
1388 | |
1389 | LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, |
1390 | llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, |
1391 | unsigned CVRQualifiers) override; |
1392 | llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, |
1393 | const ObjCInterfaceDecl *Interface, |
1394 | const ObjCIvarDecl *Ivar) override; |
1395 | }; |
1396 | |
1397 | class CGObjCNonFragileABIMac : public CGObjCCommonMac { |
1398 | private: |
1399 | friend ProtocolMethodLists; |
1400 | ObjCNonFragileABITypesHelper ObjCTypes; |
1401 | llvm::GlobalVariable* ObjCEmptyCacheVar; |
1402 | llvm::Constant* ObjCEmptyVtableVar; |
1403 | |
1404 | |
1405 | llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences; |
1406 | |
1407 | |
1408 | llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences; |
1409 | |
1410 | |
1411 | llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences; |
1412 | |
1413 | |
1414 | |
1415 | llvm::DenseSet<Selector> VTableDispatchMethods; |
1416 | |
1417 | |
1418 | std::vector<llvm::GlobalValue*> DefinedMetaClasses; |
1419 | |
1420 | |
1421 | |
1422 | bool isVTableDispatchedSelector(Selector Sel); |
1423 | |
1424 | |
1425 | |
1426 | void FinishNonFragileABIModule(); |
1427 | |
1428 | |
1429 | |
1430 | void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container, |
1431 | StringRef SymbolName, StringRef SectionName); |
1432 | |
1433 | llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags, |
1434 | unsigned InstanceStart, |
1435 | unsigned InstanceSize, |
1436 | const ObjCImplementationDecl *ID); |
1437 | llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI, |
1438 | bool isMetaclass, |
1439 | llvm::Constant *IsAGV, |
1440 | llvm::Constant *SuperClassGV, |
1441 | llvm::Constant *ClassRoGV, |
1442 | bool HiddenVisibility); |
1443 | |
1444 | void emitMethodConstant(ConstantArrayBuilder &builder, |
1445 | const ObjCMethodDecl *MD, |
1446 | bool forProtocol); |
1447 | |
1448 | |
1449 | |
1450 | llvm::Constant *emitMethodList(Twine Name, MethodListType MLT, |
1451 | ArrayRef<const ObjCMethodDecl *> Methods); |
1452 | |
1453 | |
1454 | |
1455 | |
1456 | |
1457 | |
1458 | llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID); |
1459 | |
1460 | llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID, |
1461 | const ObjCIvarDecl *Ivar, |
1462 | unsigned long int offset); |
1463 | |
1464 | |
1465 | |
1466 | |
1467 | llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override; |
1468 | |
1469 | |
1470 | |
1471 | |
1472 | |
1473 | llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override; |
1474 | |
1475 | |
1476 | |
1477 | llvm::Constant *EmitProtocolList(Twine Name, |
1478 | ObjCProtocolDecl::protocol_iterator begin, |
1479 | ObjCProtocolDecl::protocol_iterator end); |
1480 | |
1481 | CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF, |
1482 | ReturnValueSlot Return, |
1483 | QualType ResultType, |
1484 | Selector Sel, |
1485 | llvm::Value *Receiver, |
1486 | QualType Arg0Ty, |
1487 | bool IsSuper, |
1488 | const CallArgList &CallArgs, |
1489 | const ObjCMethodDecl *Method); |
1490 | |
1491 | |
1492 | |
1493 | llvm::Constant *GetClassGlobal(StringRef Name, |
1494 | ForDefinition_t IsForDefinition, |
1495 | bool Weak = false, bool DLLImport = false); |
1496 | llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID, |
1497 | bool isMetaclass, |
1498 | ForDefinition_t isForDefinition); |
1499 | |
1500 | llvm::Constant *GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID); |
1501 | |
1502 | llvm::Value *EmitLoadOfClassRef(CodeGenFunction &CGF, |
1503 | const ObjCInterfaceDecl *ID, |
1504 | llvm::GlobalVariable *Entry); |
1505 | |
1506 | |
1507 | |
1508 | llvm::Value *EmitClassRef(CodeGenFunction &CGF, |
1509 | const ObjCInterfaceDecl *ID); |
1510 | |
1511 | llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF, |
1512 | IdentifierInfo *II, |
1513 | const ObjCInterfaceDecl *ID); |
1514 | |
1515 | llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; |
1516 | |
1517 | |
1518 | |
1519 | llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF, |
1520 | const ObjCInterfaceDecl *ID); |
1521 | |
1522 | |
1523 | |
1524 | llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF, |
1525 | const ObjCInterfaceDecl *ID, bool Weak); |
1526 | |
1527 | |
1528 | |
1529 | |
1530 | llvm::GlobalVariable * ObjCIvarOffsetVariable( |
1531 | const ObjCInterfaceDecl *ID, |
1532 | const ObjCIvarDecl *Ivar); |
1533 | |
1534 | |
1535 | |
1536 | llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel); |
1537 | Address EmitSelectorAddr(Selector Sel); |
1538 | |
1539 | |
1540 | |
1541 | llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID, |
1542 | ForDefinition_t IsForDefinition); |
1543 | |
1544 | StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; } |
1545 | |
1546 | StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; } |
1547 | |
1548 | void GetClassSizeInfo(const ObjCImplementationDecl *OID, |
1549 | uint32_t &InstanceStart, |
1550 | uint32_t &InstanceSize); |
1551 | |
1552 | |
1553 | Selector GetNullarySelector(const char* name) const { |
1554 | IdentifierInfo* II = &CGM.getContext().Idents.get(name); |
1555 | return CGM.getContext().Selectors.getSelector(0, &II); |
1556 | } |
1557 | |
1558 | Selector GetUnarySelector(const char* name) const { |
1559 | IdentifierInfo* II = &CGM.getContext().Idents.get(name); |
1560 | return CGM.getContext().Selectors.getSelector(1, &II); |
1561 | } |
1562 | |
1563 | |
1564 | |
1565 | bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const; |
1566 | |
1567 | bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF, |
1568 | const ObjCIvarDecl *IV) { |
1569 | |
1570 | |
1571 | |
1572 | |
1573 | |
1574 | |
1575 | |
1576 | |
1577 | |
1578 | |
1579 | |
1580 | |
1581 | |
1582 | |
1583 | if (const ObjCMethodDecl *MD = |
1584 | dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl)) |
1585 | if (MD->isInstanceMethod() && !MD->isDirectMethod()) |
1586 | if (const ObjCInterfaceDecl *ID = MD->getClassInterface()) |
1587 | return IV->getContainingInterface()->isSuperClassOf(ID); |
1588 | return false; |
1589 | } |
1590 | |
1591 | bool isClassLayoutKnownStatically(const ObjCInterfaceDecl *ID) { |
1592 | |
1593 | |
1594 | |
1595 | |
1596 | return ID->getImplementation() && ID->getSuperClass() && |
1597 | ID->getSuperClass()->getName() == "NSObject"; |
1598 | } |
1599 | |
1600 | public: |
1601 | CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm); |
1602 | |
1603 | llvm::Constant *getNSConstantStringClassRef() override; |
1604 | |
1605 | llvm::Function *ModuleInitFunction() override; |
1606 | |
1607 | CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, |
1608 | ReturnValueSlot Return, |
1609 | QualType ResultType, Selector Sel, |
1610 | llvm::Value *Receiver, |
1611 | const CallArgList &CallArgs, |
1612 | const ObjCInterfaceDecl *Class, |
1613 | const ObjCMethodDecl *Method) override; |
1614 | |
1615 | CodeGen::RValue |
1616 | GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, |
1617 | ReturnValueSlot Return, QualType ResultType, |
1618 | Selector Sel, const ObjCInterfaceDecl *Class, |
1619 | bool isCategoryImpl, llvm::Value *Receiver, |
1620 | bool IsClassMessage, const CallArgList &CallArgs, |
1621 | const ObjCMethodDecl *Method) override; |
1622 | |
1623 | llvm::Value *GetClass(CodeGenFunction &CGF, |
1624 | const ObjCInterfaceDecl *ID) override; |
1625 | |
1626 | llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override |
1627 | { return EmitSelector(CGF, Sel); } |
1628 | Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override |
1629 | { return EmitSelectorAddr(Sel); } |
1630 | |
1631 | |
1632 | |
1633 | llvm::Value *GetSelector(CodeGenFunction &CGF, |
1634 | const ObjCMethodDecl *Method) override |
1635 | { return EmitSelector(CGF, Method->getSelector()); } |
1636 | |
1637 | void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; |
1638 | |
1639 | void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; |
1640 | |
1641 | void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {} |
1642 | |
1643 | llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, |
1644 | const ObjCProtocolDecl *PD) override; |
1645 | |
1646 | llvm::Constant *GetEHType(QualType T) override; |
1647 | |
1648 | llvm::FunctionCallee GetPropertyGetFunction() override { |
1649 | return ObjCTypes.getGetPropertyFn(); |
1650 | } |
1651 | llvm::FunctionCallee GetPropertySetFunction() override { |
1652 | return ObjCTypes.getSetPropertyFn(); |
1653 | } |
1654 | |
1655 | llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, |
1656 | bool copy) override { |
1657 | return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy); |
1658 | } |
1659 | |
1660 | llvm::FunctionCallee GetSetStructFunction() override { |
1661 | return ObjCTypes.getCopyStructFn(); |
1662 | } |
1663 | |
1664 | llvm::FunctionCallee GetGetStructFunction() override { |
1665 | return ObjCTypes.getCopyStructFn(); |
1666 | } |
1667 | |
1668 | llvm::FunctionCallee GetCppAtomicObjectSetFunction() override { |
1669 | return ObjCTypes.getCppAtomicObjectFunction(); |
1670 | } |
1671 | |
1672 | llvm::FunctionCallee GetCppAtomicObjectGetFunction() override { |
1673 | return ObjCTypes.getCppAtomicObjectFunction(); |
1674 | } |
1675 | |
1676 | llvm::FunctionCallee EnumerationMutationFunction() override { |
1677 | return ObjCTypes.getEnumerationMutationFn(); |
1678 | } |
1679 | |
1680 | void EmitTryStmt(CodeGen::CodeGenFunction &CGF, |
1681 | const ObjCAtTryStmt &S) override; |
1682 | void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, |
1683 | const ObjCAtSynchronizedStmt &S) override; |
1684 | void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, |
1685 | bool ClearInsertionPoint=true) override; |
1686 | llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, |
1687 | Address AddrWeakObj) override; |
1688 | void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, |
1689 | llvm::Value *src, Address edst) override; |
1690 | void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, |
1691 | llvm::Value *src, Address dest, |
1692 | bool threadlocal = false) override; |
1693 | void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, |
1694 | llvm::Value *src, Address dest, |
1695 | llvm::Value *ivarOffset) override; |
1696 | void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, |
1697 | llvm::Value *src, Address dest) override; |
1698 | void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, |
1699 | Address dest, Address src, |
1700 | llvm::Value *size) override; |
1701 | LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, |
1702 | llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, |
1703 | unsigned CVRQualifiers) override; |
1704 | llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, |
1705 | const ObjCInterfaceDecl *Interface, |
1706 | const ObjCIvarDecl *Ivar) override; |
1707 | }; |
1708 | |
1709 | |
1710 | |
1711 | struct NullReturnState { |
1712 | llvm::BasicBlock *NullBB; |
1713 | NullReturnState() : NullBB(nullptr) {} |
1714 | |
1715 | |
1716 | void init(CodeGenFunction &CGF, llvm::Value *receiver) { |
1717 | |
1718 | NullBB = CGF.createBasicBlock("msgSend.null-receiver"); |
1719 | llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call"); |
1720 | |
1721 | |
1722 | |
1723 | |
1724 | |
1725 | llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver); |
1726 | CGF.Builder.CreateCondBr(isNull, NullBB, callBB); |
1727 | |
1728 | |
1729 | CGF.EmitBlock(callBB); |
1730 | } |
1731 | |
1732 | |
1733 | |
1734 | RValue complete(CodeGenFunction &CGF, |
1735 | ReturnValueSlot returnSlot, |
1736 | RValue result, |
1737 | QualType resultType, |
1738 | const CallArgList &CallArgs, |
1739 | const ObjCMethodDecl *Method) { |
1740 | |
1741 | if (!NullBB) return result; |
1742 | |
1743 | |
1744 | |
1745 | llvm::BasicBlock *contBB = nullptr; |
1746 | |
1747 | |
1748 | llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock(); |
1749 | if (callBB) { |
1750 | contBB = CGF.createBasicBlock("msgSend.cont"); |
1751 | CGF.Builder.CreateBr(contBB); |
1752 | } |
1753 | |
1754 | |
1755 | CGF.EmitBlock(NullBB); |
1756 | |
1757 | |
1758 | if (Method) { |
1759 | CallArgList::const_iterator I = CallArgs.begin(); |
1760 | for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(), |
1761 | e = Method->param_end(); i != e; ++i, ++I) { |
1762 | const ParmVarDecl *ParamDecl = (*i); |
1763 | if (ParamDecl->hasAttr<NSConsumedAttr>()) { |
1764 | RValue RV = I->getRValue(CGF); |
1765 | assert(RV.isScalar() && |
1766 | "NullReturnState::complete - arg not on object"); |
1767 | CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime); |
1768 | } else { |
1769 | QualType QT = ParamDecl->getType(); |
1770 | auto *RT = QT->getAs<RecordType>(); |
1771 | if (RT && RT->getDecl()->isParamDestroyedInCallee()) { |
1772 | RValue RV = I->getRValue(CGF); |
1773 | QualType::DestructionKind DtorKind = QT.isDestructedType(); |
1774 | switch (DtorKind) { |
1775 | case QualType::DK_cxx_destructor: |
1776 | CGF.destroyCXXObject(CGF, RV.getAggregateAddress(), QT); |
1777 | break; |
1778 | case QualType::DK_nontrivial_c_struct: |
1779 | CGF.destroyNonTrivialCStruct(CGF, RV.getAggregateAddress(), QT); |
1780 | break; |
1781 | default: |
1782 | llvm_unreachable("unexpected dtor kind"); |
1783 | break; |
1784 | } |
1785 | } |
1786 | } |
1787 | } |
1788 | } |
1789 | |
1790 | |
1791 | assert(CGF.Builder.GetInsertBlock() == NullBB); |
1792 | |
1793 | |
1794 | if (result.isScalar() && resultType->isVoidType()) { |
1795 | |
1796 | if (contBB) CGF.EmitBlock(contBB); |
1797 | return result; |
1798 | } |
1799 | |
1800 | |
1801 | if (result.isScalar()) { |
1802 | |
1803 | llvm::Value *null = |
1804 | CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(resultType), resultType); |
1805 | |
1806 | |
1807 | if (!contBB) return RValue::get(null); |
1808 | |
1809 | |
1810 | CGF.EmitBlock(contBB); |
1811 | llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2); |
1812 | phi->addIncoming(result.getScalarVal(), callBB); |
1813 | phi->addIncoming(null, NullBB); |
1814 | return RValue::get(phi); |
1815 | } |
1816 | |
1817 | |
1818 | |
1819 | |
1820 | |
1821 | if (result.isAggregate()) { |
1822 | assert(result.isAggregate() && "null init of non-aggregate result?"); |
1823 | if (!returnSlot.isUnused()) |
1824 | CGF.EmitNullInitialization(result.getAggregateAddress(), resultType); |
1825 | if (contBB) CGF.EmitBlock(contBB); |
1826 | return result; |
1827 | } |
1828 | |
1829 | |
1830 | CGF.EmitBlock(contBB); |
1831 | CodeGenFunction::ComplexPairTy callResult = result.getComplexVal(); |
1832 | |
1833 | |
1834 | llvm::Type *scalarTy = callResult.first->getType(); |
1835 | llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy); |
1836 | |
1837 | |
1838 | llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2); |
1839 | real->addIncoming(callResult.first, callBB); |
1840 | real->addIncoming(scalarZero, NullBB); |
1841 | llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2); |
1842 | imag->addIncoming(callResult.second, callBB); |
1843 | imag->addIncoming(scalarZero, NullBB); |
1844 | return RValue::getComplex(real, imag); |
1845 | } |
1846 | }; |
1847 | |
1848 | } |
1849 | |
1850 | |
1851 | |
1852 | |
1853 | static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext, |
1854 | llvm::GlobalVariable *C, unsigned idx0, |
1855 | unsigned idx1) { |
1856 | llvm::Value *Idxs[] = { |
1857 | llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0), |
1858 | llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1) |
1859 | }; |
1860 | return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs); |
1861 | } |
1862 | |
1863 | |
1864 | |
1865 | static bool hasObjCExceptionAttribute(ASTContext &Context, |
1866 | const ObjCInterfaceDecl *OID) { |
1867 | if (OID->hasAttr<ObjCExceptionAttr>()) |
1868 | return true; |
1869 | if (const ObjCInterfaceDecl *Super = OID->getSuperClass()) |
1870 | return hasObjCExceptionAttribute(Context, Super); |
1871 | return false; |
1872 | } |
1873 | |
1874 | static llvm::GlobalValue::LinkageTypes |
1875 | getLinkageTypeForObjCMetadata(CodeGenModule &CGM, StringRef Section) { |
1876 | if (CGM.getTriple().isOSBinFormatMachO() && |
1877 | (Section.empty() || Section.startswith("__DATA"))) |
1878 | return llvm::GlobalValue::InternalLinkage; |
1879 | return llvm::GlobalValue::PrivateLinkage; |
1880 | } |
1881 | |
1882 | |
1883 | static llvm::GlobalVariable * |
1884 | finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder, |
1885 | const llvm::Twine &Name, CodeGenModule &CGM) { |
1886 | std::string SectionName; |
1887 | if (CGM.getTriple().isOSBinFormatMachO()) |
1888 | SectionName = "__DATA, __objc_const"; |
1889 | auto *GV = Builder.finishAndCreateGlobal( |
1890 | Name, CGM.getPointerAlign(), false, |
1891 | getLinkageTypeForObjCMetadata(CGM, SectionName)); |
1892 | GV->setSection(SectionName); |
1893 | return GV; |
1894 | } |
1895 | |
1896 | |
1897 | |
1898 | CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm), |
1899 | ObjCTypes(cgm) { |
1900 | ObjCABI = 1; |
1901 | EmitImageInfo(); |
1902 | } |
1903 | |
1904 | |
1905 | |
1906 | llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF, |
1907 | const ObjCInterfaceDecl *ID) { |
1908 | return EmitClassRef(CGF, ID); |
1909 | } |
1910 | |
1911 | |
1912 | llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) { |
1913 | return EmitSelector(CGF, Sel); |
1914 | } |
1915 | Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) { |
1916 | return EmitSelectorAddr(Sel); |
1917 | } |
1918 | llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl |
1919 | *Method) { |
1920 | return EmitSelector(CGF, Method->getSelector()); |
1921 | } |
1922 | |
1923 | llvm::Constant *CGObjCMac::GetEHType(QualType T) { |
1924 | if (T->isObjCIdType() || |
1925 | T->isObjCQualifiedIdType()) { |
1926 | return CGM.GetAddrOfRTTIDescriptor( |
1927 | CGM.getContext().getObjCIdRedefinitionType(), true); |
1928 | } |
1929 | if (T->isObjCClassType() || |
1930 | T->isObjCQualifiedClassType()) { |
1931 | return CGM.GetAddrOfRTTIDescriptor( |
1932 | CGM.getContext().getObjCClassRedefinitionType(), true); |
1933 | } |
1934 | if (T->isObjCObjectPointerType()) |
1935 | return CGM.GetAddrOfRTTIDescriptor(T, true); |
1936 | |
1937 | llvm_unreachable("asking for catch type for ObjC type in fragile runtime"); |
1938 | } |
1939 | |
1940 | |
1941 | |
1942 | |
1943 | |
1944 | |
1945 | |
1946 | |
1947 | |
1948 | |
1949 | |
1950 | |
1951 | |
1952 | |
1953 | |
1954 | |
1955 | |
1956 | |
1957 | |
1958 | |
1959 | ConstantAddress |
1960 | CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) { |
1961 | return (!CGM.getLangOpts().NoConstantCFStrings |
1962 | ? CGM.GetAddrOfConstantCFString(SL) |
1963 | : GenerateConstantNSString(SL)); |
1964 | } |
1965 | |
1966 | static llvm::StringMapEntry<llvm::GlobalVariable *> & |
1967 | GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map, |
1968 | const StringLiteral *Literal, unsigned &StringLength) { |
1969 | StringRef String = Literal->getString(); |
1970 | StringLength = String.size(); |
1971 | return *Map.insert(std::make_pair(String, nullptr)).first; |
1972 | } |
1973 | |
1974 | llvm::Constant *CGObjCMac::getNSConstantStringClassRef() { |
1975 | if (llvm::Value *V = ConstantStringClassRef) |
1976 | return cast<llvm::Constant>(V); |
1977 | |
1978 | auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass; |
1979 | std::string str = |
1980 | StringClass.empty() ? "_NSConstantStringClassReference" |
1981 | : "_" + StringClass + "ClassReference"; |
1982 | |
1983 | llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0); |
1984 | auto GV = CGM.CreateRuntimeVariable(PTy, str); |
1985 | auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo()); |
1986 | ConstantStringClassRef = V; |
1987 | return V; |
1988 | } |
1989 | |
1990 | llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() { |
1991 | if (llvm::Value *V = ConstantStringClassRef) |
1992 | return cast<llvm::Constant>(V); |
1993 | |
1994 | auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass; |
1995 | std::string str = |
1996 | StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" |
1997 | : "OBJC_CLASS_$_" + StringClass; |
1998 | llvm::Constant *GV = GetClassGlobal(str, NotForDefinition); |
1999 | |
2000 | |
2001 | auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo()); |
2002 | |
2003 | ConstantStringClassRef = V; |
2004 | return V; |
2005 | } |
2006 | |
2007 | ConstantAddress |
2008 | CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) { |
2009 | unsigned StringLength = 0; |
2010 | llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = |
2011 | GetConstantStringEntry(NSConstantStringMap, Literal, StringLength); |
2012 | |
2013 | if (auto *C = Entry.second) |
2014 | return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment())); |
2015 | |
2016 | |
2017 | llvm::Constant *Class = getNSConstantStringClassRef(); |
2018 | |
2019 | |
2020 | if (!NSConstantStringType) { |
2021 | NSConstantStringType = |
2022 | llvm::StructType::create({ |
2023 | CGM.Int32Ty->getPointerTo(), |
2024 | CGM.Int8PtrTy, |
2025 | CGM.IntTy |
2026 | }, "struct.__builtin_NSString"); |
2027 | } |
2028 | |
2029 | ConstantInitBuilder Builder(CGM); |
2030 | auto Fields = Builder.beginStruct(NSConstantStringType); |
2031 | |
2032 | |
2033 | Fields.add(Class); |
2034 | |
2035 | |
2036 | llvm::Constant *C = |
2037 | llvm::ConstantDataArray::getString(VMContext, Entry.first()); |
2038 | |
2039 | llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage; |
2040 | bool isConstant = !CGM.getLangOpts().WritableStrings; |
2041 | |
2042 | auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant, |
2043 | Linkage, C, ".str"); |
2044 | GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); |
2045 | |
2046 | |
2047 | GV->setAlignment(llvm::Align(1)); |
2048 | Fields.addBitCast(GV, CGM.Int8PtrTy); |
2049 | |
2050 | |
2051 | Fields.addInt(CGM.IntTy, StringLength); |
2052 | |
2053 | |
2054 | CharUnits Alignment = CGM.getPointerAlign(); |
2055 | GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment, |
2056 | true, |
2057 | llvm::GlobalVariable::PrivateLinkage); |
2058 | const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip"; |
2059 | const char *NSStringNonFragileABISection = |
2060 | "__DATA,__objc_stringobj,regular,no_dead_strip"; |
2061 | |
2062 | GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile() |
2063 | ? NSStringNonFragileABISection |
2064 | : NSStringSection); |
2065 | Entry.second = GV; |
2066 | |
2067 | return ConstantAddress(GV, Alignment); |
2068 | } |
2069 | |
2070 | enum { |
2071 | kCFTaggedObjectID_Integer = (1 << 1) + 1 |
2072 | }; |
2073 | |
2074 | |
2075 | |
2076 | |
2077 | CodeGen::RValue |
2078 | CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, |
2079 | ReturnValueSlot Return, |
2080 | QualType ResultType, |
2081 | Selector Sel, |
2082 | const ObjCInterfaceDecl *Class, |
2083 | bool isCategoryImpl, |
2084 | llvm::Value *Receiver, |
2085 | bool IsClassMessage, |
2086 | const CodeGen::CallArgList &CallArgs, |
2087 | const ObjCMethodDecl *Method) { |
2088 | |
2089 | |
2090 | Address ObjCSuper = |
2091 | CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(), |
2092 | "objc_super"); |
2093 | llvm::Value *ReceiverAsObject = |
2094 | CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy); |
2095 | CGF.Builder.CreateStore(ReceiverAsObject, |
2096 | CGF.Builder.CreateStructGEP(ObjCSuper, 0)); |
2097 | |
2098 | |
2099 | llvm::Type *ClassTyPtr = llvm::PointerType::getUnqual(ObjCTypes.ClassTy); |
2100 | llvm::Value *Target; |
2101 | if (IsClassMessage) { |
2102 | if (isCategoryImpl) { |
2103 | |
2104 | |
2105 | |
2106 | |
2107 | |
2108 | |
2109 | Target = EmitClassRef(CGF, Class->getSuperClass()); |
2110 | Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0); |
2111 | Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, Target, |
2112 | CGF.getPointerAlign()); |
2113 | } else { |
2114 | llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class); |
2115 | llvm::Value *SuperPtr = |
2116 | CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1); |
2117 | llvm::Value *Super = CGF.Builder.CreateAlignedLoad(ClassTyPtr, SuperPtr, |
2118 | CGF.getPointerAlign()); |
2119 | Target = Super; |
2120 | } |
2121 | } else if (isCategoryImpl) |
2122 | Target = EmitClassRef(CGF, Class->getSuperClass()); |
2123 | else { |
2124 | llvm::Value *ClassPtr = EmitSuperClassRef(Class); |
2125 | ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1); |
2126 | Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, ClassPtr, |
2127 | CGF.getPointerAlign()); |
2128 | } |
2129 | |
2130 | |
2131 | llvm::Type *ClassTy = |
2132 | CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType()); |
2133 | Target = CGF.Builder.CreateBitCast(Target, ClassTy); |
2134 | CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1)); |
2135 | return EmitMessageSend(CGF, Return, ResultType, Sel, ObjCSuper.getPointer(), |
2136 | ObjCTypes.SuperPtrCTy, true, CallArgs, Method, Class, |
2137 | ObjCTypes); |
2138 | } |
2139 | |
2140 | |
2141 | CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF, |
2142 | ReturnValueSlot Return, |
2143 | QualType ResultType, |
2144 | Selector Sel, |
2145 | llvm::Value *Receiver, |
2146 | const CallArgList &CallArgs, |
2147 | const ObjCInterfaceDecl *Class, |
2148 | const ObjCMethodDecl *Method) { |
2149 | return EmitMessageSend(CGF, Return, ResultType, Sel, Receiver, |
2150 | CGF.getContext().getObjCIdType(), false, CallArgs, |
2151 | Method, Class, ObjCTypes); |
2152 | } |
2153 | |
2154 | static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) { |
2155 | do { |
2156 | if (ID->isWeakImported()) |
2157 | return true; |
2158 | } while ((ID = ID->getSuperClass())); |
2159 | |
2160 | return false; |
2161 | } |
2162 | |
2163 | CodeGen::RValue |
2164 | CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF, |
2165 | ReturnValueSlot Return, |
2166 | QualType ResultType, |
2167 | Selector Sel, |
2168 | llvm::Value *Arg0, |
2169 | QualType Arg0Ty, |
2170 | bool IsSuper, |
2171 | const CallArgList &CallArgs, |
2172 | const ObjCMethodDecl *Method, |
2173 | const ObjCInterfaceDecl *ClassReceiver, |
2174 | const ObjCCommonTypesHelper &ObjCTypes) { |
2175 | CodeGenTypes &Types = CGM.getTypes(); |
2176 | auto selTy = CGF.getContext().getObjCSelType(); |
2177 | llvm::Value *SelValue; |
2178 | |
2179 | if (Method && Method->isDirectMethod()) { |
2180 | |
2181 | |
2182 | assert(!IsSuper); |
2183 | SelValue = llvm::UndefValue::get(Types.ConvertType(selTy)); |
2184 | } else { |
2185 | SelValue = GetSelector(CGF, Sel); |
2186 | } |
2187 | |
2188 | CallArgList ActualArgs; |
2189 | if (!IsSuper) |
2190 | Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy); |
2191 | ActualArgs.add(RValue::get(Arg0), Arg0Ty); |
2192 | ActualArgs.add(RValue::get(SelValue), selTy); |
2193 | ActualArgs.addFrom(CallArgs); |
2194 | |
2195 | |
2196 | MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs); |
2197 | |
2198 | if (Method) |
2199 | assert(CGM.getContext().getCanonicalType(Method->getReturnType()) == |
2200 | CGM.getContext().getCanonicalType(ResultType) && |
2201 | "Result type mismatch!"); |
2202 | |
2203 | bool ReceiverCanBeNull = true; |
2204 | |
2205 | |
2206 | |
2207 | if (IsSuper) { |
2208 | ReceiverCanBeNull = false; |
2209 | |
2210 | |
2211 | |
2212 | } else if (ClassReceiver && Method && Method->isClassMethod()) { |
2213 | ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver); |
2214 | |
2215 | |
2216 | |
2217 | } else if (auto CurMethod = |
2218 | dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) { |
2219 | auto Self = CurMethod->getSelfDecl(); |
2220 | if (Self->getType().isConstQualified()) { |
2221 | if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) { |
2222 | llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer(); |
2223 | if (SelfAddr == LI->getPointerOperand()) { |
2224 | ReceiverCanBeNull = false; |
2225 | } |
2226 | } |
2227 | } |
2228 | } |
2229 | |
2230 | bool RequiresNullCheck = false; |
2231 | |
2232 | llvm::FunctionCallee Fn = nullptr; |
2233 | if (Method && Method->isDirectMethod()) { |
2234 | Fn = GenerateDirectMethod(Method, Method->getClassInterface()); |
2235 | } else if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) { |
2236 | if (ReceiverCanBeNull) RequiresNullCheck = true; |
2237 | Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper) |
2238 | : ObjCTypes.getSendStretFn(IsSuper); |
2239 | } else if (CGM.ReturnTypeUsesFPRet(ResultType)) { |
2240 | Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper) |
2241 | : ObjCTypes.getSendFpretFn(IsSuper); |
2242 | } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) { |
2243 | Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper) |
2244 | : ObjCTypes.getSendFp2retFn(IsSuper); |
2245 | } else { |
2246 | |
2247 | |
2248 | if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo)) |
2249 | RequiresNullCheck = true; |
2250 | Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper) |
2251 | : ObjCTypes.getSendFn(IsSuper); |
2252 | } |
2253 | |
2254 | |
2255 | llvm::Constant *BitcastFn = cast<llvm::Constant>( |
2256 | CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType)); |
2257 | |
2258 | |
2259 | |
2260 | if (Return.isUnused()) |
2261 | RequiresNullCheck = false; |
2262 | |
2263 | |
2264 | if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) { |
2265 | for (const auto *ParamDecl : Method->parameters()) { |
2266 | if (ParamDecl->isDestroyedInCallee()) { |
2267 | RequiresNullCheck = true; |
2268 | break; |
2269 | } |
2270 | } |
2271 | } |
2272 | |
2273 | NullReturnState nullReturn; |
2274 | if (RequiresNullCheck) { |
2275 | nullReturn.init(CGF, Arg0); |
2276 | } |
2277 | |
2278 | llvm::CallBase *CallSite; |
2279 | CGCallee Callee = CGCallee::forDirect(BitcastFn); |
2280 | RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs, |
2281 | &CallSite); |
2282 | |
2283 | |
2284 | |
2285 | if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) { |
2286 | CallSite->setDoesNotReturn(); |
2287 | } |
2288 | |
2289 | return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs, |
2290 | RequiresNullCheck ? Method : nullptr); |
2291 | } |
2292 | |
2293 | static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT, |
2294 | bool pointee = false) { |
2295 | |
2296 | |
2297 | |
2298 | if (FQT.isObjCGCStrong()) |
2299 | return Qualifiers::Strong; |
2300 | |
2301 | if (FQT.isObjCGCWeak()) |
2302 | return Qualifiers::Weak; |
2303 | |
2304 | if (auto ownership = FQT.getObjCLifetime()) { |
2305 | |
2306 | if (pointee) return Qualifiers::GCNone; |
2307 | switch (ownership) { |
2308 | case Qualifiers::OCL_Weak: return Qualifiers::Weak; |
2309 | case Qualifiers::OCL_Strong: return Qualifiers::Strong; |
2310 | case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone; |
2311 | case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?"); |
2312 | case Qualifiers::OCL_None: llvm_unreachable("known nonzero"); |
2313 | } |
2314 | llvm_unreachable("bad objc ownership"); |
2315 | } |
2316 | |
2317 | |
2318 | if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType()) |
2319 | return Qualifiers::Strong; |
2320 | |
2321 | |
2322 | if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) { |
2323 | if (const PointerType *PT = FQT->getAs<PointerType>()) |
2324 | return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), true); |
2325 | } |
2326 | |
2327 | return Qualifiers::GCNone; |
2328 | } |
2329 | |
2330 | namespace { |
2331 | struct IvarInfo { |
2332 | CharUnits Offset; |
2333 | uint64_t SizeInWords; |
2334 | IvarInfo(CharUnits offset, uint64_t sizeInWords) |
2335 | : Offset(offset), SizeInWords(sizeInWords) {} |
2336 | |
2337 | |
2338 | bool operator<(const IvarInfo &other) const { |
2339 | return Offset < other.Offset; |
2340 | } |
2341 | }; |
2342 | |
2343 | |
2344 | class IvarLayoutBuilder { |
2345 | CodeGenModule &CGM; |
2346 | |
2347 | |
2348 | |
2349 | CharUnits InstanceBegin; |
2350 | |
2351 | |
2352 | CharUnits InstanceEnd; |
2353 | |
2354 | |
2355 | bool ForStrongLayout; |
2356 | |
2357 | |
2358 | bool IsDisordered = false; |
2359 | |
2360 | llvm::SmallVector<IvarInfo, 8> IvarsInfo; |
2361 | |
2362 | public: |
2363 | IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin, |
2364 | CharUnits instanceEnd, bool forStrongLayout) |
2365 | : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd), |
2366 | ForStrongLayout(forStrongLayout) { |
2367 | } |
2368 | |
2369 | void visitRecord(const RecordType *RT, CharUnits offset); |
2370 | |
2371 | template <class Iterator, class GetOffsetFn> |
2372 | void visitAggregate(Iterator begin, Iterator end, |
2373 | CharUnits aggrOffset, |
2374 | const GetOffsetFn &getOffset); |
2375 | |
2376 | void visitField(const FieldDecl *field, CharUnits offset); |
2377 | |
2378 | |
2379 | void visitBlock(const CGBlockInfo &blockInfo); |
2380 | |
2381 | |
2382 | bool hasBitmapData() const { return !IvarsInfo.empty(); } |
2383 | |
2384 | llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC, |
2385 | llvm::SmallVectorImpl<unsigned char> &buffer); |
2386 | |
2387 | static void dump(ArrayRef<unsigned char> buffer) { |
2388 | const unsigned char *s = buffer.data(); |
2389 | for (unsigned i = 0, e = buffer.size(); i < e; i++) |
2390 | if (!(s[i] & 0xf0)) |
2391 | printf("0x0%x%s", s[i], s[i] != 0 ? ", " : ""); |
2392 | else |
2393 | printf("0x%x%s", s[i], s[i] != 0 ? ", " : ""); |
2394 | printf("\n"); |
2395 | } |
2396 | }; |
2397 | } |
2398 | |
2399 | llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM, |
2400 | const CGBlockInfo &blockInfo) { |
2401 | |
2402 | llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); |
2403 | if (CGM.getLangOpts().getGC() == LangOptions::NonGC) |
2404 | return nullPtr; |
2405 | |
2406 | IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize, |
2407 | true); |
2408 | |
2409 | builder.visitBlock(blockInfo); |
2410 | |
2411 | if (!builder.hasBitmapData()) |
2412 | return nullPtr; |
2413 | |
2414 | llvm::SmallVector<unsigned char, 32> buffer; |
2415 | llvm::Constant *C = builder.buildBitmap(*this, buffer); |
2416 | if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) { |
2417 | printf("\n block variable layout for block: "); |
2418 | builder.dump(buffer); |
2419 | } |
2420 | |
2421 | return C; |
2422 | } |
2423 | |
2424 | void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) { |
2425 | |
2426 | |
2427 | IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1)); |
2428 | |
2429 | const BlockDecl *blockDecl = blockInfo.getBlockDecl(); |
2430 | |
2431 | |
2432 | |
2433 | |
2434 | CharUnits lastFieldOffset; |
2435 | |
2436 | |
2437 | for (const auto &CI : blockDecl->captures()) { |
2438 | const VarDecl *variable = CI.getVariable(); |
2439 | QualType type = variable->getType(); |
2440 | |
2441 | const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); |
2442 | |
2443 | |
2444 | if (capture.isConstant()) continue; |
2445 | |
2446 | CharUnits fieldOffset = capture.getOffset(); |
2447 | |
2448 | |
2449 | |
2450 | if (fieldOffset < lastFieldOffset) |
2451 | IsDisordered = true; |
2452 | lastFieldOffset = fieldOffset; |
2453 | |
2454 | |
2455 | if (CI.isByRef()) { |
2456 | IvarsInfo.push_back(IvarInfo(fieldOffset, 1)); |
2457 | continue; |
2458 | } |
2459 | |
2460 | assert(!type->isArrayType() && "array variable should not be caught"); |
2461 | if (const RecordType *record = type->getAs<RecordType>()) { |
2462 | visitRecord(record, fieldOffset); |
2463 | continue; |
2464 | } |
2465 | |
2466 | Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type); |
2467 | |
2468 | if (GCAttr == Qualifiers::Strong) { |
2469 | assert(CGM.getContext().getTypeSize(type) |
2470 | == CGM.getTarget().getPointerWidth(0)); |
2471 | IvarsInfo.push_back(IvarInfo(fieldOffset, 1)); |
2472 | } |
2473 | } |
2474 | } |
2475 | |
2476 | |
2477 | |
2478 | |
2479 | Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT, |
2480 | bool ByrefLayout) { |
2481 | |
2482 | if (auto lifetime = FQT.getObjCLifetime()) |
2483 | return lifetime; |
2484 | |
2485 | |
2486 | if (CGM.getLangOpts().ObjCAutoRefCount) |
2487 | return Qualifiers::OCL_None; |
2488 | |
2489 | |
2490 | if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType()) |
2491 | return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong; |
2492 | |
2493 | return Qualifiers::OCL_None; |
2494 | } |
2495 | |
2496 | void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref, |
2497 | Qualifiers::ObjCLifetime LifeTime, |
2498 | CharUnits FieldOffset, |
2499 | CharUnits FieldSize) { |
2500 | |
2501 | if (IsByref) |
2502 | RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset, |
2503 | FieldSize)); |
2504 | else if (LifeTime == Qualifiers::OCL_Strong) |
2505 | RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset, |
2506 | FieldSize)); |
2507 | else if (LifeTime == Qualifiers::OCL_Weak) |
2508 | RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset, |
2509 | FieldSize)); |
2510 | else if (LifeTime == Qualifiers::OCL_ExplicitNone) |
2511 | RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset, |
2512 | FieldSize)); |
2513 | else |
2514 | RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES, |
2515 | FieldOffset, |
2516 | FieldSize)); |
2517 | } |
2518 | |
2519 | void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout, |
2520 | const RecordDecl *RD, |
2521 | ArrayRef<const FieldDecl*> RecFields, |
2522 | CharUnits BytePos, bool &HasUnion, |
2523 | bool ByrefLayout) { |
2524 | bool IsUnion = (RD && RD->isUnion()); |
2525 | CharUnits MaxUnionSize = CharUnits::Zero(); |
2526 | const FieldDecl *MaxField = nullptr; |
2527 | const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr; |
2528 | CharUnits MaxFieldOffset = CharUnits::Zero(); |
2529 | CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero(); |
2530 | |
2531 | if (RecFields.empty()) |
2532 | return; |
2533 | unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); |
2534 | |
2535 | for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { |
2536 | const FieldDecl *Field = RecFields[i]; |
2537 | |
2538 | |
2539 | const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); |
2540 | CharUnits FieldOffset = |
2541 | CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i)); |
2542 | |
2543 | |
2544 | if (!Field->getIdentifier() || Field->isBitField()) { |
2545 | LastFieldBitfieldOrUnnamed = Field; |
2546 | LastBitfieldOrUnnamedOffset = FieldOffset; |
2547 | continue; |
2548 | } |
2549 | |
2550 | LastFieldBitfieldOrUnnamed = nullptr; |
2551 | QualType FQT = Field->getType(); |
2552 | if (FQT->isRecordType() || FQT->isUnionType()) { |
2553 | if (FQT->isUnionType()) |
2554 | HasUnion = true; |
2555 | |
2556 | BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(), |
2557 | BytePos + FieldOffset, HasUnion); |
2558 | continue; |
2559 | } |
2560 | |
2561 | if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { |
2562 | auto *CArray = cast<ConstantArrayType>(Array); |
2563 | uint64_t ElCount = CArray->getSize().getZExtValue(); |
2564 | assert(CArray && "only array with known element size is supported"); |
2565 | FQT = CArray->getElementType(); |
2566 | while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { |
2567 | auto *CArray = cast<ConstantArrayType>(Array); |
2568 | ElCount *= CArray->getSize().getZExtValue(); |
2569 | FQT = CArray->getElementType(); |
2570 | } |
2571 | if (FQT->isRecordType() && ElCount) { |
2572 | int OldIndex = RunSkipBlockVars.size() - 1; |
2573 | auto *RT = FQT->castAs<RecordType>(); |
2574 | BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset, HasUnion); |
2575 | |
2576 | |
2577 | |
2578 | uint64_t ElIx = 1; |
2579 | for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) { |
2580 | CharUnits Size = CGM.getContext().getTypeSizeInChars(RT); |
2581 | for (int i = OldIndex+1; i <= FirstIndex; ++i) |
2582 | RunSkipBlockVars.push_back( |
2583 | RUN_SKIP(RunSkipBlockVars[i].opcode, |
2584 | RunSkipBlockVars[i].block_var_bytepos + Size*ElIx, |
2585 | RunSkipBlockVars[i].block_var_size)); |
2586 | } |
2587 | continue; |
2588 | } |
2589 | } |
2590 | CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType()); |
2591 | if (IsUnion) { |
2592 | CharUnits UnionIvarSize = FieldSize; |
2593 | if (UnionIvarSize > MaxUnionSize) { |
2594 | MaxUnionSize = UnionIvarSize; |
2595 | MaxField = Field; |
2596 | MaxFieldOffset = FieldOffset; |
2597 | } |
2598 | } else { |
2599 | UpdateRunSkipBlockVars(false, |
2600 | getBlockCaptureLifetime(FQT, ByrefLayout), |
2601 | BytePos + FieldOffset, |
2602 | FieldSize); |
2603 | } |
2604 | } |
2605 | |
2606 | if (LastFieldBitfieldOrUnnamed) { |
2607 | if (LastFieldBitfieldOrUnnamed->isBitField()) { |
2608 | |
2609 | uint64_t BitFieldSize |
2610 | = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext()); |
2611 | unsigned UnsSize = (BitFieldSize / ByteSizeInBits) + |
2612 | ((BitFieldSize % ByteSizeInBits) != 0); |
2613 | CharUnits Size = CharUnits::fromQuantity(UnsSize); |
2614 | Size += LastBitfieldOrUnnamedOffset; |
2615 | UpdateRunSkipBlockVars(false, |
2616 | getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(), |
2617 | ByrefLayout), |
2618 | BytePos + LastBitfieldOrUnnamedOffset, |
2619 | Size); |
2620 | } else { |
2621 | assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed"); |
2622 | |
2623 | CharUnits FieldSize |
2624 | = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType()); |
2625 | UpdateRunSkipBlockVars(false, |
2626 | getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(), |
2627 | ByrefLayout), |
2628 | BytePos + LastBitfieldOrUnnamedOffset, |
2629 | FieldSize); |
2630 | } |
2631 | } |
2632 | |
2633 | if (MaxField) |
2634 | UpdateRunSkipBlockVars(false, |
2635 | getBlockCaptureLifetime(MaxField->getType(), ByrefLayout), |
2636 | BytePos + MaxFieldOffset, |
2637 | MaxUnionSize); |
2638 | } |
2639 | |
2640 | void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT, |
2641 | CharUnits BytePos, |
2642 | bool &HasUnion, |
2643 | bool ByrefLayout) { |
2644 | const RecordDecl *RD = RT->getDecl(); |
2645 | SmallVector<const FieldDecl*, 16> Fields(RD->fields()); |
2646 | llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0)); |
2647 | const llvm::StructLayout *RecLayout = |
2648 | CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty)); |
2649 | |
2650 | BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout); |
2651 | } |
2652 | |
2653 | |
2654 | |
2655 | |
2656 | |
2657 | |
2658 | |
2659 | |
2660 | |
2661 | |
2662 | uint64_t CGObjCCommonMac::InlineLayoutInstruction( |
2663 | SmallVectorImpl<unsigned char> &Layout) { |
2664 | uint64_t Result = 0; |
2665 | if (Layout.size() <= 3) { |
2666 | unsigned size = Layout.size(); |
2667 | unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0; |
2668 | unsigned char inst; |
2669 | enum BLOCK_LAYOUT_OPCODE opcode ; |
2670 | switch (size) { |
2671 | case 3: |
2672 | inst = Layout[0]; |
2673 | opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2674 | if (opcode == BLOCK_LAYOUT_STRONG) |
2675 | strong_word_count = (inst & 0xF)+1; |
2676 | else |
2677 | return 0; |
2678 | inst = Layout[1]; |
2679 | opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2680 | if (opcode == BLOCK_LAYOUT_BYREF) |
2681 | byref_word_count = (inst & 0xF)+1; |
2682 | else |
2683 | return 0; |
2684 | inst = Layout[2]; |
2685 | opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2686 | if (opcode == BLOCK_LAYOUT_WEAK) |
2687 | weak_word_count = (inst & 0xF)+1; |
2688 | else |
2689 | return 0; |
2690 | break; |
2691 | |
2692 | case 2: |
2693 | inst = Layout[0]; |
2694 | opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2695 | if (opcode == BLOCK_LAYOUT_STRONG) { |
2696 | strong_word_count = (inst & 0xF)+1; |
2697 | inst = Layout[1]; |
2698 | opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2699 | if (opcode == BLOCK_LAYOUT_BYREF) |
2700 | byref_word_count = (inst & 0xF)+1; |
2701 | else if (opcode == BLOCK_LAYOUT_WEAK) |
2702 | weak_word_count = (inst & 0xF)+1; |
2703 | else |
2704 | return 0; |
2705 | } |
2706 | else if (opcode == BLOCK_LAYOUT_BYREF) { |
2707 | byref_word_count = (inst & 0xF)+1; |
2708 | inst = Layout[1]; |
2709 | opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2710 | if (opcode == BLOCK_LAYOUT_WEAK) |
2711 | weak_word_count = (inst & 0xF)+1; |
2712 | else |
2713 | return 0; |
2714 | } |
2715 | else |
2716 | return 0; |
2717 | break; |
2718 | |
2719 | case 1: |
2720 | inst = Layout[0]; |
2721 | opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2722 | if (opcode == BLOCK_LAYOUT_STRONG) |
2723 | strong_word_count = (inst & 0xF)+1; |
2724 | else if (opcode == BLOCK_LAYOUT_BYREF) |
2725 | byref_word_count = (inst & 0xF)+1; |
2726 | else if (opcode == BLOCK_LAYOUT_WEAK) |
2727 | weak_word_count = (inst & 0xF)+1; |
2728 | else |
2729 | return 0; |
2730 | break; |
2731 | |
2732 | default: |
2733 | return 0; |
2734 | } |
2735 | |
2736 | |
2737 | |
2738 | |
2739 | if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16) |
2740 | return 0; |
2741 | |
2742 | unsigned count = |
2743 | (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0); |
2744 | |
2745 | if (size == count) { |
2746 | if (strong_word_count) |
2747 | Result = strong_word_count; |
2748 | Result <<= 4; |
2749 | if (byref_word_count) |
2750 | Result += byref_word_count; |
2751 | Result <<= 4; |
2752 | if (weak_word_count) |
2753 | Result += weak_word_count; |
2754 | } |
2755 | } |
2756 | return Result; |
2757 | } |
2758 | |
2759 | llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) { |
2760 | llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); |
2761 | if (RunSkipBlockVars.empty()) |
2762 | return nullPtr; |
2763 | unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0); |
2764 | unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); |
2765 | unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits; |
2766 | |
2767 | |
2768 | |
2769 | llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end()); |
2770 | SmallVector<unsigned char, 16> Layout; |
2771 | |
2772 | unsigned size = RunSkipBlockVars.size(); |
2773 | for (unsigned i = 0; i < size; i++) { |
2774 | enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode; |
2775 | CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos; |
2776 | CharUnits end_byte_pos = start_byte_pos; |
2777 | unsigned j = i+1; |
2778 | while (j < size) { |
2779 | if (opcode == RunSkipBlockVars[j].opcode) { |
2780 | end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos; |
2781 | i++; |
2782 | } |
2783 | else |
2784 | break; |
2785 | } |
2786 | CharUnits size_in_bytes = |
2787 | end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size; |
2788 | if (j < size) { |
2789 | CharUnits gap = |
2790 | RunSkipBlockVars[j].block_var_bytepos - |
2791 | RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size; |
2792 | size_in_bytes += gap; |
2793 | } |
2794 | CharUnits residue_in_bytes = CharUnits::Zero(); |
2795 | if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) { |
2796 | residue_in_bytes = size_in_bytes % WordSizeInBytes; |
2797 | size_in_bytes -= residue_in_bytes; |
2798 | opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS; |
2799 | } |
2800 | |
2801 | unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes; |
2802 | while (size_in_words >= 16) { |
2803 | |
2804 | |
2805 | unsigned char inst = (opcode << 4) | 0xf; |
2806 | Layout.push_back(inst); |
2807 | size_in_words -= 16; |
2808 | } |
2809 | if (size_in_words > 0) { |
2810 | |
2811 | |
2812 | unsigned char inst = (opcode << 4) | (size_in_words-1); |
2813 | Layout.push_back(inst); |
2814 | } |
2815 | if (residue_in_bytes > CharUnits::Zero()) { |
2816 | unsigned char inst = |
2817 | (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1); |
2818 | Layout.push_back(inst); |
2819 | } |
2820 | } |
2821 | |
2822 | while (!Layout.empty()) { |
2823 | unsigned char inst = Layout.back(); |
2824 | enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2825 | if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS) |
2826 | Layout.pop_back(); |
2827 | else |
2828 | break; |
2829 | } |
2830 | |
2831 | uint64_t Result = InlineLayoutInstruction(Layout); |
2832 | if (Result != 0) { |
2833 | |
2834 | if (CGM.getLangOpts().ObjCGCBitmapPrint) { |
2835 | if (ComputeByrefLayout) |
2836 | printf("\n Inline BYREF variable layout: "); |
2837 | else |
2838 | printf("\n Inline block variable layout: "); |
2839 | printf("0x0%" PRIx64 "", Result); |
2840 | if (auto numStrong = (Result & 0xF00) >> 8) |
2841 | printf(", BL_STRONG:%d", (int) numStrong); |
2842 | if (auto numByref = (Result & 0x0F0) >> 4) |
2843 | printf(", BL_BYREF:%d", (int) numByref); |
2844 | if (auto numWeak = (Result & 0x00F) >> 0) |
2845 | printf(", BL_WEAK:%d", (int) numWeak); |
2846 | printf(", BL_OPERATOR:0\n"); |
2847 | } |
2848 | return llvm::ConstantInt::get(CGM.IntPtrTy, Result); |
2849 | } |
2850 | |
2851 | unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0; |
2852 | Layout.push_back(inst); |
2853 | std::string BitMap; |
2854 | for (unsigned i = 0, e = Layout.size(); i != e; i++) |
2855 | BitMap += Layout[i]; |
2856 | |
2857 | if (CGM.getLangOpts().ObjCGCBitmapPrint) { |
2858 | if (ComputeByrefLayout) |
2859 | printf("\n Byref variable layout: "); |
2860 | else |
2861 | printf("\n Block variable layout: "); |
2862 | for (unsigned i = 0, e = BitMap.size(); i != e; i++) { |
2863 | unsigned char inst = BitMap[i]; |
2864 | enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
2865 | unsigned delta = 1; |
2866 | switch (opcode) { |
2867 | case BLOCK_LAYOUT_OPERATOR: |
2868 | printf("BL_OPERATOR:"); |
2869 | delta = 0; |
2870 | break; |
2871 | case BLOCK_LAYOUT_NON_OBJECT_BYTES: |
2872 | printf("BL_NON_OBJECT_BYTES:"); |
2873 | break; |
2874 | case BLOCK_LAYOUT_NON_OBJECT_WORDS: |
2875 | printf("BL_NON_OBJECT_WORD:"); |
2876 | break; |
2877 | case BLOCK_LAYOUT_STRONG: |
2878 | printf("BL_STRONG:"); |
2879 | break; |
2880 | case BLOCK_LAYOUT_BYREF: |
2881 | printf("BL_BYREF:"); |
2882 | break; |
2883 | case BLOCK_LAYOUT_WEAK: |
2884 | printf("BL_WEAK:"); |
2885 | break; |
2886 | case BLOCK_LAYOUT_UNRETAINED: |
2887 | printf("BL_UNRETAINED:"); |
2888 | break; |
2889 | } |
2890 | |
2891 | |
2892 | printf("%d", (inst & 0xf) + delta); |
2893 | if (i < e-1) |
2894 | printf(", "); |
2895 | else |
2896 | printf("\n"); |
2897 | } |
2898 | } |
2899 | |
2900 | auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName, |
2901 | true, |
2902 | false); |
2903 | return getConstantGEP(VMContext, Entry, 0, 0); |
2904 | } |
2905 | |
2906 | static std::string getBlockLayoutInfoString( |
2907 | const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars, |
2908 | bool HasCopyDisposeHelpers) { |
2909 | std::string Str; |
2910 | for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) { |
2911 | if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) { |
2912 | |
2913 | |
2914 | Str += "u"; |
2915 | } else if (HasCopyDisposeHelpers) { |
2916 | |
2917 | |
2918 | |
2919 | |
2920 | continue; |
2921 | } else { |
2922 | switch (R.opcode) { |
2923 | case CGObjCCommonMac::BLOCK_LAYOUT_STRONG: |
2924 | Str += "s"; |
2925 | break; |
2926 | case CGObjCCommonMac::BLOCK_LAYOUT_BYREF: |
2927 | Str += "r"; |
2928 | break; |
2929 | case CGObjCCommonMac::BLOCK_LAYOUT_WEAK: |
2930 | Str += "w"; |
2931 | break; |
2932 | default: |
2933 | continue; |
2934 | } |
2935 | } |
2936 | Str += llvm::to_string(R.block_var_bytepos.getQuantity()); |
2937 | Str += "l" + llvm::to_string(R.block_var_size.getQuantity()); |
2938 | } |
2939 | return Str; |
2940 | } |
2941 | |
2942 | void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM, |
2943 | const CGBlockInfo &blockInfo) { |
2944 | assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); |
2945 | |
2946 | RunSkipBlockVars.clear(); |
2947 | bool hasUnion = false; |
2948 | |
2949 | unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0); |
2950 | unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); |
2951 | unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits; |
2952 | |
2953 | const BlockDecl *blockDecl = blockInfo.getBlockDecl(); |
2954 | |
2955 | |
2956 | const llvm::StructLayout *layout = |
2957 | CGM.getDataLayout().getStructLayout(blockInfo.StructureType); |
2958 | |
2959 | |
2960 | |
2961 | if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero()) |
2962 | UpdateRunSkipBlockVars(false, Qualifiers::OCL_None, |
2963 | blockInfo.BlockHeaderForcedGapOffset, |
2964 | blockInfo.BlockHeaderForcedGapSize); |
2965 | |
2966 | for (const auto &CI : blockDecl->captures()) { |
2967 | const VarDecl *variable = CI.getVariable(); |
2968 | QualType type = variable->getType(); |
2969 | |
2970 | const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); |
2971 | |
2972 | |
2973 | if (capture.isConstant()) continue; |
2974 | |
2975 | CharUnits fieldOffset = |
2976 | CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex())); |
2977 | |
2978 | assert(!type->isArrayType() && "array variable should not be caught"); |
2979 | if (!CI.isByRef()) |
2980 | if (const RecordType *record = type->getAs<RecordType>()) { |
2981 | BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion); |
2982 | continue; |
2983 | } |
2984 | CharUnits fieldSize; |
2985 | if (CI.isByRef()) |
2986 | fieldSize = CharUnits::fromQuantity(WordSizeInBytes); |
2987 | else |
2988 | fieldSize = CGM.getContext().getTypeSizeInChars(type); |
2989 | UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false), |
2990 | fieldOffset, fieldSize); |
2991 | } |
2992 | } |
2993 | |
2994 | llvm::Constant * |
2995 | CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM, |
2996 | const CGBlockInfo &blockInfo) { |
2997 | fillRunSkipBlockVars(CGM, blockInfo); |
2998 | return getBitmapBlockLayout(false); |
2999 | } |
3000 | |
3001 | std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM, |
3002 | const CGBlockInfo &blockInfo) { |
3003 | fillRunSkipBlockVars(CGM, blockInfo); |
3004 | return getBlockLayoutInfoString(RunSkipBlockVars, |
3005 | blockInfo.needsCopyDisposeHelpers()); |
3006 | } |
3007 | |
3008 | llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM, |
3009 | QualType T) { |
3010 | assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); |
3011 | assert(!T->isArrayType() && "__block array variable should not be caught"); |
3012 | CharUnits fieldOffset; |
3013 | RunSkipBlockVars.clear(); |
3014 | bool hasUnion = false; |
3015 | if (const RecordType *record = T->getAs<RecordType>()) { |
3016 | BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true ); |
3017 | llvm::Constant *Result = getBitmapBlockLayout(true); |
3018 | if (isa<llvm::ConstantInt>(Result)) |
3019 | Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy); |
3020 | return Result; |
3021 | } |
3022 | llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); |
3023 | return nullPtr; |
3024 | } |
3025 | |
3026 | llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF, |
3027 | const ObjCProtocolDecl *PD) { |
3028 | |
3029 | |
3030 | LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); |
3031 | |
3032 | return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD), |
3033 | ObjCTypes.getExternalProtocolPtrTy()); |
3034 | } |
3035 | |
3036 | void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) { |
3037 | |
3038 | |
3039 | DefinedProtocols.insert(PD->getIdentifier()); |
3040 | |
3041 | |
3042 | |
3043 | |
3044 | if (Protocols.count(PD->getIdentifier())) |
3045 | GetOrEmitProtocol(PD); |
3046 | } |
3047 | |
3048 | llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) { |
3049 | if (DefinedProtocols.count(PD->getIdentifier())) |
3050 | return GetOrEmitProtocol(PD); |
3051 | |
3052 | return GetOrEmitProtocolRef(PD); |
3053 | } |
3054 | |
3055 | llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime( |
3056 | CodeGenFunction &CGF, |
3057 | const ObjCInterfaceDecl *ID, |
3058 | ObjCCommonTypesHelper &ObjCTypes) { |
3059 | llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn(); |
3060 | |
3061 | llvm::Value *className = CGF.CGM |
3062 | .GetAddrOfConstantCString(std::string( |
3063 | ID->getObjCRuntimeNameAsString())) |
3064 | .getPointer(); |
3065 | ASTContext &ctx = CGF.CGM.getContext(); |
3066 | className = |
3067 | CGF.Builder.CreateBitCast(className, |
3068 | CGF.ConvertType( |
3069 | ctx.getPointerType(ctx.CharTy.withConst()))); |
3070 | llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className); |
3071 | call->setDoesNotThrow(); |
3072 | return call; |
3073 | } |
3074 | |
3075 | |
3076 | |
3077 | |
3078 | |
3079 | |
3080 | |
3081 | |
3082 | |
3083 | |
3084 | |
3085 | |
3086 | |
3087 | llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) { |
3088 | llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()]; |
3089 | |
3090 | |
3091 | if (Entry && Entry->hasInitializer()) |
3092 | return Entry; |
3093 | |
3094 | |
3095 | if (const ObjCProtocolDecl *Def = PD->getDefinition()) |
3096 | PD = Def; |
3097 | |
3098 | |
3099 | |
3100 | LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); |
3101 | |
3102 | |
3103 | auto methodLists = ProtocolMethodLists::get(PD); |
3104 | |
3105 | ConstantInitBuilder builder(CGM); |
3106 | auto values = builder.beginStruct(ObjCTypes.ProtocolTy); |
3107 | values.add(EmitProtocolExtension(PD, methodLists)); |
3108 | values.add(GetClassName(PD->getObjCRuntimeNameAsString())); |
3109 | values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(), |
3110 | PD->protocol_begin(), PD->protocol_end())); |
3111 | values.add(methodLists.emitMethodList(this, PD, |
3112 | ProtocolMethodLists::RequiredInstanceMethods)); |
3113 | values.add(methodLists.emitMethodList(this, PD, |
3114 | ProtocolMethodLists::RequiredClassMethods)); |
3115 | |
3116 | if (Entry) { |
3117 | |
3118 | assert(Entry->hasPrivateLinkage()); |
3119 | values.finishAndSetAsInitializer(Entry); |
3120 | } else { |
3121 | Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(), |
3122 | CGM.getPointerAlign(), |
3123 | false, |
3124 | llvm::GlobalValue::PrivateLinkage); |
3125 | Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); |
3126 | |
3127 | Protocols[PD->getIdentifier()] = Entry; |
3128 | } |
3129 | CGM.addCompilerUsedGlobal(Entry); |
3130 | |
3131 | return Entry; |
3132 | } |
3133 | |
3134 | llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) { |
3135 | llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; |
3136 | |
3137 | if (!Entry) { |
3138 | |
3139 | |
3140 | |
3141 | Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, |
3142 | false, llvm::GlobalValue::PrivateLinkage, |
3143 | nullptr, "OBJC_PROTOCOL_" + PD->getName()); |
3144 | Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); |
3145 | |
3146 | Entry->setAlignment(llvm::Align(4)); |
3147 | } |
3148 | |
3149 | return Entry; |
3150 | } |
3151 | |
3152 | |
3153 | |
3154 | |
3155 | |
3156 | |
3157 | |
3158 | |
3159 | |
3160 | |
3161 | |
3162 | llvm::Constant * |
3163 | CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD, |
3164 | const ProtocolMethodLists &methodLists) { |
3165 | auto optInstanceMethods = |
3166 | methodLists.emitMethodList(this, PD, |
3167 | ProtocolMethodLists::OptionalInstanceMethods); |
3168 | auto optClassMethods = |
3169 | methodLists.emitMethodList(this, PD, |
3170 | ProtocolMethodLists::OptionalClassMethods); |
3171 | |
3172 | auto extendedMethodTypes = |
3173 | EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(), |
3174 | methodLists.emitExtendedTypesArray(this), |
3175 | ObjCTypes); |
3176 | |
3177 | auto instanceProperties = |
3178 | EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD, |
3179 | ObjCTypes, false); |
3180 | auto classProperties = |
3181 | EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr, |
3182 | PD, ObjCTypes, true); |
3183 | |
3184 | |
3185 | if (optInstanceMethods->isNullValue() && |
3186 | optClassMethods->isNullValue() && |
3187 | extendedMethodTypes->isNullValue() && |
3188 | instanceProperties->isNullValue() && |
3189 | classProperties->isNullValue()) { |
3190 | return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy); |
3191 | } |
3192 | |
3193 | uint64_t size = |
3194 | CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy); |
3195 | |
3196 | ConstantInitBuilder builder(CGM); |
3197 | auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy); |
3198 | values.addInt(ObjCTypes.IntTy, size); |
3199 | values.add(optInstanceMethods); |
3200 | values.add(optClassMethods); |
3201 | values.add(instanceProperties); |
3202 | values.add(extendedMethodTypes); |
3203 | values.add(classProperties); |
3204 | |
3205 | |
3206 | return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values, |
3207 | StringRef(), CGM.getPointerAlign(), true); |
3208 | } |
3209 | |
3210 | |
3211 | |
3212 | |
3213 | |
3214 | |
3215 | |
3216 | |
3217 | llvm::Constant * |
3218 | CGObjCMac::EmitProtocolList(Twine name, |
3219 | ObjCProtocolDecl::protocol_iterator begin, |
3220 | ObjCProtocolDecl::protocol_iterator end) { |
3221 | |
3222 | auto PDs = GetRuntimeProtocolList(begin, end); |
3223 | if (PDs.empty()) |
3224 | return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); |
3225 | |
3226 | ConstantInitBuilder builder(CGM); |
3227 | auto values = builder.beginStruct(); |
3228 | |
3229 | |
3230 | values.addNullPointer(ObjCTypes.ProtocolListPtrTy); |
3231 | |
3232 | |
3233 | auto countSlot = values.addPlaceholder(); |
3234 | |
3235 | auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy); |
3236 | for (const auto *Proto : PDs) |
3237 | refsArray.add(GetProtocolRef(Proto)); |
3238 | |
3239 | auto count = refsArray.size(); |
3240 | |
3241 | |
3242 | refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy); |
3243 | |
3244 | refsArray.finishAndAddTo(values); |
3245 | values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count); |
3246 | |
3247 | StringRef section; |
3248 | if (CGM.getTriple().isOSBinFormatMachO()) |
3249 | section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; |
3250 | |
3251 | llvm::GlobalVariable *GV = |
3252 | CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false); |
3253 | return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy); |
3254 | } |
3255 | |
3256 | static void |
3257 | PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet, |
3258 | SmallVectorImpl<const ObjCPropertyDecl *> &Properties, |
3259 | const ObjCProtocolDecl *Proto, |
3260 | bool IsClassProperty) { |
3261 | for (const auto *PD : Proto->properties()) { |
3262 | if (IsClassProperty != PD->isClassProperty()) |
3263 | continue; |
3264 | if (!PropertySet.insert(PD->getIdentifier()).second) |
3265 | continue; |
3266 | Properties.push_back(PD); |
3267 | } |
3268 | |
3269 | for (const auto *P : Proto->protocols()) |
3270 | PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); |
3271 | } |
3272 | |
3273 | |
3274 | |
3275 | |
3276 | |
3277 | |
3278 | |
3279 | |
3280 | |
3281 | |
3282 | |
3283 | |
3284 | |
3285 | llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name, |
3286 | const Decl *Container, |
3287 | const ObjCContainerDecl *OCD, |
3288 | const ObjCCommonTypesHelper &ObjCTypes, |
3289 | bool IsClassProperty) { |
3290 | if (IsClassProperty) { |
3291 | |
3292 | |
3293 | const llvm::Triple &Triple = CGM.getTarget().getTriple(); |
3294 | if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) || |
3295 | (Triple.isiOS() && Triple.isOSVersionLT(9))) |
3296 | return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); |
3297 | } |
3298 | |
3299 | SmallVector<const ObjCPropertyDecl *, 16> Properties; |
3300 | llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet; |
3301 | |
3302 | if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) |
3303 | for (const ObjCCategoryDecl *ClassExt : OID->known_extensions()) |
3304 | for (auto *PD : ClassExt->properties()) { |
3305 | if (IsClassProperty != PD->isClassProperty()) |
3306 | continue; |
3307 | if (PD->isDirectProperty()) |
3308 | continue; |
3309 | PropertySet.insert(PD->getIdentifier()); |
3310 | Properties.push_back(PD); |
3311 | } |
3312 | |
3313 | for (const auto *PD : OCD->properties()) { |
3314 | if (IsClassProperty != PD->isClassProperty()) |
3315 | continue; |
3316 | |
3317 | |
3318 | if (!PropertySet.insert(PD->getIdentifier()).second) |
3319 | continue; |
3320 | if (PD->isDirectProperty()) |
3321 | continue; |
3322 | Properties.push_back(PD); |
3323 | } |
3324 | |
3325 | if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) { |
3326 | for (const auto *P : OID->all_referenced_protocols()) |
3327 | PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); |
3328 | } |
3329 | else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) { |
3330 | for (const auto *P : CD->protocols()) |
3331 | PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); |
3332 | } |
3333 | |
3334 | |
3335 | if (Properties.empty()) |
3336 | return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); |
3337 | |
3338 | unsigned propertySize = |
3339 | CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy); |
3340 | |
3341 | ConstantInitBuilder builder(CGM); |
3342 | auto values = builder.beginStruct(); |
3343 | values.addInt(ObjCTypes.IntTy, propertySize); |
3344 | values.addInt(ObjCTypes.IntTy, Properties.size()); |
3345 | auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy); |
3346 | for (auto PD : Properties) { |
3347 | auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy); |
3348 | property.add(GetPropertyName(PD->getIdentifier())); |
3349 | property.add(GetPropertyTypeString(PD, Container)); |
3350 | property.finishAndAddTo(propertiesArray); |
3351 | } |
3352 | propertiesArray.finishAndAddTo(values); |
3353 | |
3354 | StringRef Section; |
3355 | if (CGM.getTriple().isOSBinFormatMachO()) |
3356 | Section = (ObjCABI == 2) ? "__DATA, __objc_const" |
3357 | : "__OBJC,__property,regular,no_dead_strip"; |
3358 | |
3359 | llvm::GlobalVariable *GV = |
3360 | CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true); |
3361 | return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy); |
3362 | } |
3363 | |
3364 | llvm::Constant * |
3365 | CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name, |
3366 | ArrayRef<llvm::Constant*> MethodTypes, |
3367 | const ObjCCommonTypesHelper &ObjCTypes) { |
3368 | |
3369 | if (MethodTypes.empty()) |
3370 | return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy); |
3371 | |
3372 | llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, |
3373 | MethodTypes.size()); |
3374 | llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes); |
3375 | |
3376 | StringRef Section; |
3377 | if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2) |
3378 | Section = "__DATA, __objc_const"; |
3379 | |
3380 | llvm::GlobalVariable *GV = |
3381 | CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true); |
3382 | return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy); |
3383 | } |
3384 | |
3385 | |
3386 | |
3387 | |
3388 | |
3389 | |
3390 | |
3391 | |
3392 | |
3393 | |
3394 | |
3395 | |
3396 | |
3397 | void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) { |
3398 | unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy); |
3399 | |
3400 | |
3401 | |
3402 | |
3403 | |
3404 | const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); |
3405 | const ObjCCategoryDecl *Category = |
3406 | Interface->FindCategoryDeclaration(OCD->getIdentifier()); |
3407 | |
3408 | SmallString<256> ExtName; |
3409 | llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_' |
3410 | << OCD->getName(); |
3411 | |
3412 | ConstantInitBuilder Builder(CGM); |
3413 | auto Values = Builder.beginStruct(ObjCTypes.CategoryTy); |
3414 | |
3415 | enum { |
3416 | InstanceMethods, |
3417 | ClassMethods, |
3418 | NumMethodLists |
3419 | }; |
3420 | SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists]; |
3421 | for (const auto *MD : OCD->methods()) { |
3422 | if (!MD->isDirectMethod()) |
3423 | Methods[unsigned(MD->isClassMethod())].push_back(MD); |
3424 | } |
3425 | |
3426 | Values.add(GetClassName(OCD->getName())); |
3427 | Values.add(GetClassName(Interface->getObjCRuntimeNameAsString())); |
3428 | LazySymbols.insert(Interface->getIdentifier()); |
3429 | |
3430 | Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods, |
3431 | Methods[InstanceMethods])); |
3432 | Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods, |
3433 | Methods[ClassMethods])); |
3434 | if (Category) { |
3435 | Values.add( |
3436 | EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(), |
3437 | Category->protocol_begin(), Category->protocol_end())); |
3438 | } else { |
3439 | Values.addNullPointer(ObjCTypes.ProtocolListPtrTy); |
3440 | } |
3441 | Values.addInt(ObjCTypes.IntTy, Size); |
3442 | |
3443 | |
3444 | if (Category) { |
3445 | Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(), |
3446 | OCD, Category, ObjCTypes, false)); |
3447 | Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(), |
3448 | OCD, Category, ObjCTypes, true)); |
3449 | } else { |
3450 | Values.addNullPointer(ObjCTypes.PropertyListPtrTy); |
3451 | Values.addNullPointer(ObjCTypes.PropertyListPtrTy); |
3452 | } |
3453 | |
3454 | llvm::GlobalVariable *GV = |
3455 | CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values, |
3456 | "__OBJC,__category,regular,no_dead_strip", |
3457 | CGM.getPointerAlign(), true); |
3458 | DefinedCategories.push_back(GV); |
3459 | DefinedCategoryNames.insert(llvm::CachedHashString(ExtName)); |
3460 | |
3461 | MethodDefinitions.clear(); |
3462 | } |
3463 | |
3464 | enum FragileClassFlags { |
3465 | |
3466 | FragileABI_Class_Factory = 0x00001, |
3467 | |
3468 | |
3469 | FragileABI_Class_Meta = 0x00002, |
3470 | |
3471 | |
3472 | FragileABI_Class_HasCXXStructors = 0x02000, |
3473 | |
3474 | |
3475 | FragileABI_Class_Hidden = 0x20000, |
3476 | |
3477 | |
3478 | FragileABI_Class_CompiledByARC = 0x04000000, |
3479 | |
3480 | |
3481 | |
3482 | FragileABI_Class_HasMRCWeakIvars = 0x08000000, |
3483 | }; |
3484 | |
3485 | enum NonFragileClassFlags { |
3486 | |
3487 | NonFragileABI_Class_Meta = 0x00001, |
3488 | |
3489 | |
3490 | NonFragileABI_Class_Root = 0x00002, |
3491 | |
3492 | |
3493 | NonFragileABI_Class_HasCXXStructors = 0x00004, |
3494 | |
3495 | |
3496 | NonFragileABI_Class_Hidden = 0x00010, |
3497 | |
3498 | |
3499 | NonFragileABI_Class_Exception = 0x00020, |
3500 | |
3501 | |
3502 | NonFragileABI_Class_HasIvarReleaser = 0x00040, |
3503 | |
3504 | |
3505 | NonFragileABI_Class_CompiledByARC = 0x00080, |
3506 | |
3507 | |
3508 | NonFragileABI_Class_HasCXXDestructorOnly = 0x00100, |
3509 | |
3510 | |
3511 | |
3512 | NonFragileABI_Class_HasMRCWeakIvars = 0x00200, |
3513 | }; |
3514 | |
3515 | static bool hasWeakMember(QualType type) { |
3516 | if (type.getObjCLifetime() == Qualifiers::OCL_Weak) { |
3517 | return true; |
3518 | } |
3519 | |
3520 | if (auto recType = type->getAs<RecordType>()) { |
3521 | for (auto field : recType->getDecl()->fields()) { |
3522 | if (hasWeakMember(field->getType())) |
3523 | return true; |
3524 | } |
3525 | } |
3526 | |
3527 | return false; |
3528 | } |
3529 | |
3530 | |
3531 | |
3532 | |
3533 | static bool hasMRCWeakIvars(CodeGenModule &CGM, |
3534 | const ObjCImplementationDecl *ID) { |
3535 | if (!CGM.getLangOpts().ObjCWeak) return false; |
3536 | assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); |
3537 | |
3538 | for (const ObjCIvarDecl *ivar = |
3539 | ID->getClassInterface()->all_declared_ivar_begin(); |
3540 | ivar; ivar = ivar->getNextIvar()) { |
3541 | if (hasWeakMember(ivar->getType())) |
3542 | return true; |
3543 | } |
3544 | |
3545 | return false; |
3546 | } |
3547 | |
3548 | |
3549 | |
3550 | |
3551 | |
3552 | |
3553 | |
3554 | |
3555 | |
3556 | |
3557 | |
3558 | |
3559 | |
3560 | |
3561 | |
3562 | |
3563 | |
3564 | |
3565 | |
3566 | |
3567 | void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) { |
3568 | IdentifierInfo *RuntimeName = |
3569 | &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString()); |
3570 | DefinedSymbols.insert(RuntimeName); |
3571 | |
3572 | std::string ClassName = ID->getNameAsString(); |
3573 | |
3574 | ObjCInterfaceDecl *Interface = |
3575 | const_cast<ObjCInterfaceDecl*>(ID->getClassInterface()); |
3576 | llvm::Constant *Protocols = |
3577 | EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(), |
3578 | Interface->all_referenced_protocol_begin(), |
3579 | Interface->all_referenced_protocol_end()); |
3580 | unsigned Flags = FragileABI_Class_Factory; |
3581 | if (ID->hasNonZeroConstructors() || ID->hasDestructors()) |
3582 | Flags |= FragileABI_Class_HasCXXStructors; |
3583 | |
3584 | bool hasMRCWeak = false; |
3585 | |
3586 | if (CGM.getLangOpts().ObjCAutoRefCount) |
3587 | Flags |= FragileABI_Class_CompiledByARC; |
3588 | else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID))) |
3589 | Flags |= FragileABI_Class_HasMRCWeakIvars; |
3590 | |
3591 | CharUnits Size = |
3592 | CGM.getContext().getASTObjCImplementationLayout(ID).getSize(); |
3593 | |
3594 | |
3595 | if (ID->getClassInterface()->getVisibility() == HiddenVisibility) |
3596 | Flags |= FragileABI_Class_Hidden; |
3597 | |
3598 | enum { |
3599 | InstanceMethods, |
3600 | ClassMethods, |
3601 | NumMethodLists |
3602 | }; |
3603 | SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists]; |
3604 | for (const auto *MD : ID->methods()) { |
3605 | if (!MD->isDirectMethod()) |
3606 | Methods[unsigned(MD->isClassMethod())].push_back(MD); |
3607 | } |
3608 | |
3609 | for (const auto *PID : ID->property_impls()) { |
3610 | if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { |
3611 | if (PID->getPropertyDecl()->isDirectProperty()) |
3612 | continue; |
3613 | if (ObjCMethodDecl *MD = PID->getGetterMethodDecl()) |
3614 | if (GetMethodDefinition(MD)) |
3615 | Methods[InstanceMethods].push_back(MD); |
3616 | if (ObjCMethodDecl *MD = PID->getSetterMethodDecl()) |
3617 | if (GetMethodDefinition(MD)) |
3618 | Methods[InstanceMethods].push_back(MD); |
3619 | } |
3620 | } |
3621 | |
3622 | ConstantInitBuilder builder(CGM); |
3623 | auto values = builder.beginStruct(ObjCTypes.ClassTy); |
3624 | values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods])); |
3625 | if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) { |
3626 | |
3627 | LazySymbols.insert(Super->getIdentifier()); |
3628 | |
3629 | values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()), |
3630 | ObjCTypes.ClassPtrTy); |
3631 | } else { |
3632 | values.addNullPointer(ObjCTypes.ClassPtrTy); |
3633 | } |
3634 | values.add(GetClassName(ID->getObjCRuntimeNameAsString())); |
3635 | |
3636 | values.addInt(ObjCTypes.LongTy, 0); |
3637 | values.addInt(ObjCTypes.LongTy, Flags); |
3638 | values.addInt(ObjCTypes.LongTy, Size.getQuantity()); |
3639 | values.add(EmitIvarList(ID, false)); |
3640 | values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods, |
3641 | Methods[InstanceMethods])); |
3642 | |
3643 | values.addNullPointer(ObjCTypes.CachePtrTy); |
3644 | values.add(Protocols); |
3645 | values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size)); |
3646 | values.add(EmitClassExtension(ID, Size, hasMRCWeak, |
3647 | false)); |
3648 | |
3649 | std::string Name("OBJC_CLASS_"); |
3650 | Name += ClassName; |
3651 | const char *Section = "__OBJC,__class,regular,no_dead_strip"; |
3652 | |
3653 | llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); |
3654 | if (GV) { |
3655 | assert(GV->getValueType() == ObjCTypes.ClassTy && |
3656 | "Forward metaclass reference has incorrect type."); |
3657 | values.finishAndSetAsInitializer(GV); |
3658 | GV->setSection(Section); |
3659 | GV->setAlignment(CGM.getPointerAlign().getAsAlign()); |
3660 | CGM.addCompilerUsedGlobal(GV); |
3661 | } else |
3662 | GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true); |
3663 | DefinedClasses.push_back(GV); |
3664 | ImplementedClasses.push_back(Interface); |
3665 | |
3666 | MethodDefinitions.clear(); |
3667 | } |
3668 | |
3669 | llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID, |
3670 | llvm::Constant *Protocols, |
3671 | ArrayRef<const ObjCMethodDecl*> Methods) { |
3672 | unsigned Flags = FragileABI_Class_Meta; |
3673 | unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy); |
3674 | |
3675 | if (ID->getClassInterface()->getVisibility() == HiddenVisibility) |
3676 | Flags |= FragileABI_Class_Hidden; |
3677 | |
3678 | ConstantInitBuilder builder(CGM); |
3679 | auto values = builder.beginStruct(ObjCTypes.ClassTy); |
3680 | |
3681 | const ObjCInterfaceDecl *Root = ID->getClassInterface(); |
3682 | while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) |
3683 | Root = Super; |
3684 | values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()), |
3685 | ObjCTypes.ClassPtrTy); |
3686 | |
3687 | |
3688 | |
3689 | if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) { |
3690 | values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()), |
3691 | ObjCTypes.ClassPtrTy); |
3692 | } else { |
3693 | values.addNullPointer(ObjCTypes.ClassPtrTy); |
3694 | } |
3695 | values.add(GetClassName(ID->getObjCRuntimeNameAsString())); |
3696 | |
3697 | values.addInt(ObjCTypes.LongTy, 0); |
3698 | values.addInt(ObjCTypes.LongTy, Flags); |
3699 | values.addInt(ObjCTypes.LongTy, Size); |
3700 | values.add(EmitIvarList(ID, true)); |
3701 | values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods, |
3702 | Methods)); |
3703 | |
3704 | values.addNullPointer(ObjCTypes.CachePtrTy); |
3705 | values.add(Protocols); |
3706 | |
3707 | values.addNullPointer(ObjCTypes.Int8PtrTy); |
3708 | |
3709 | values.add(EmitClassExtension(ID, CharUnits::Zero(), false, |
3710 | true)); |
3711 | |
3712 | std::string Name("OBJC_METACLASS_"); |
3713 | Name += ID->getName(); |
3714 | |
3715 | |
3716 | llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); |
3717 | if (GV) { |
3718 | assert(GV->getValueType() == ObjCTypes.ClassTy && |
3719 | "Forward metaclass reference has incorrect type."); |
3720 | values.finishAndSetAsInitializer(GV); |
3721 | } else { |
3722 | GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(), |
3723 | false, |
3724 | llvm::GlobalValue::PrivateLinkage); |
3725 | } |
3726 | GV->setSection("__OBJC,__meta_class,regular,no_dead_strip"); |
3727 | CGM.addCompilerUsedGlobal(GV); |
3728 | |
3729 | return GV; |
3730 | } |
3731 | |
3732 | llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) { |
3733 | std::string Name = "OBJC_METACLASS_" + ID->getNameAsString(); |
3734 | |
3735 | |
3736 | |
3737 | |
3738 | |
3739 | |
3740 | |
3741 | |
3742 | |
3743 | llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); |
3744 | if (!GV) |
3745 | GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false, |
3746 | llvm::GlobalValue::PrivateLinkage, nullptr, |
3747 | Name); |
3748 | |
3749 | assert(GV->getValueType() == ObjCTypes.ClassTy && |
3750 | "Forward metaclass reference has incorrect type."); |
3751 | return GV; |
3752 | } |
3753 | |
3754 | llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) { |
3755 | std::string Name = "OBJC_CLASS_" + ID->getNameAsString(); |
3756 | llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); |
3757 | |
3758 | if (!GV) |
3759 | GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false, |
3760 | llvm::GlobalValue::PrivateLinkage, nullptr, |
3761 | Name); |
3762 | |
3763 | assert(GV->getValueType() == ObjCTypes.ClassTy && |
3764 | "Forward class metadata reference has incorrect type."); |
3765 | return GV; |
3766 | } |
3767 | |
3768 | |
3769 | |
3770 | |
3771 | |
3772 | |
3773 | |
3774 | |
3775 | |
3776 | |
3777 | |
3778 | |
3779 | llvm::Constant * |
3780 | CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID, |
3781 | CharUnits InstanceSize, bool hasMRCWeakIvars, |
3782 | bool isMetaclass) { |
3783 | |
3784 | llvm::Constant *layout; |
3785 | if (isMetaclass) { |
3786 | layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy); |
3787 | } else { |
3788 | layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize, |
3789 | hasMRCWeakIvars); |
3790 | } |
3791 | |
3792 | |
3793 | llvm::Constant *propertyList = |
3794 | EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_") |
3795 | : Twine("_OBJC_$_PROP_LIST_")) |
3796 | + ID->getName(), |
3797 | ID, ID->getClassInterface(), ObjCTypes, isMetaclass); |
3798 | |
3799 | |
3800 | if (layout->isNullValue() && propertyList->isNullValue()) { |
3801 | return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy); |
3802 | } |
3803 | |
3804 | uint64_t size = |
3805 | CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy); |
3806 | |
3807 | ConstantInitBuilder builder(CGM); |
3808 | auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy); |
3809 | values.addInt(ObjCTypes.IntTy, size); |
3810 | values.add(layout); |
3811 | values.add(propertyList); |
3812 | |
3813 | return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values, |
3814 | "__OBJC,__class_ext,regular,no_dead_strip", |
3815 | CGM.getPointerAlign(), true); |
3816 | } |
3817 | |
3818 | |
3819 | |
3820 | |
3821 | |
3822 | |
3823 | |
3824 | |
3825 | |
3826 | |
3827 | |
3828 | |
3829 | |
3830 | llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID, |
3831 | bool ForClass) { |
3832 | |
3833 | |
3834 | |
3835 | |
3836 | |
3837 | if (ForClass) |
3838 | return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); |
3839 | |
3840 | const ObjCInterfaceDecl *OID = ID->getClassInterface(); |
3841 | |
3842 | ConstantInitBuilder builder(CGM); |
3843 | auto ivarList = builder.beginStruct(); |
3844 | auto countSlot = ivarList.addPlaceholder(); |
3845 | auto ivars = ivarList.beginArray(ObjCTypes.IvarTy); |
3846 | |
3847 | for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin(); |
3848 | IVD; IVD = IVD->getNextIvar()) { |
3849 | |
3850 | if (!IVD->getDeclName()) |
3851 | continue; |
3852 | |
3853 | auto ivar = ivars.beginStruct(ObjCTypes.IvarTy); |
3854 | ivar.add(GetMethodVarName(IVD->getIdentifier())); |
3855 | ivar.add(GetMethodVarType(IVD)); |
3856 | ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD)); |
3857 | ivar.finishAndAddTo(ivars); |
3858 | } |
3859 | |
3860 | |
3861 | auto count = ivars.size(); |
3862 | if (count == 0) { |
3863 | ivars.abandon(); |
3864 | ivarList.abandon(); |
3865 | return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); |
3866 | } |
3867 | |
3868 | ivars.finishAndAddTo(ivarList); |
3869 | ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count); |
3870 | |
3871 | llvm::GlobalVariable *GV; |
3872 | if (ForClass) |
3873 | GV = |
3874 | CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList, |
3875 | "__OBJC,__class_vars,regular,no_dead_strip", |
3876 | CGM.getPointerAlign(), true); |
3877 | else |
3878 | GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList, |
3879 | "__OBJC,__instance_vars,regular,no_dead_strip", |
3880 | CGM.getPointerAlign(), true); |
3881 | return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy); |
3882 | } |
3883 | |
3884 | |
3885 | |
3886 | |
3887 | |
3888 | |
3889 | |
3890 | void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder, |
3891 | const ObjCMethodDecl *MD) { |
3892 | auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy); |
3893 | description.addBitCast(GetMethodVarName(MD->getSelector()), |
3894 | ObjCTypes.SelectorPtrTy); |
3895 | description.add(GetMethodVarType(MD)); |
3896 | description.finishAndAddTo(builder); |
3897 | } |
3898 | |
3899 | |
3900 | |
3901 | |
3902 | |
3903 | |
3904 | |
3905 | |
3906 | void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder, |
3907 | const ObjCMethodDecl *MD) { |
3908 | llvm::Function *fn = GetMethodDefinition(MD); |
3909 | assert(fn && "no definition registered for method"); |
3910 | |
3911 | auto method = builder.beginStruct(ObjCTypes.MethodTy); |
3912 | method.addBitCast(GetMethodVarName(MD->getSelector()), |
3913 | ObjCTypes.SelectorPtrTy); |
3914 | method.add(GetMethodVarType(MD)); |
3915 | method.addBitCast(fn, ObjCTypes.Int8PtrTy); |
3916 | method.finishAndAddTo(builder); |
3917 | } |
3918 | |
3919 | |
3920 | |
3921 | |
3922 | |
3923 | |
3924 | |
3925 | |
3926 | |
3927 | |
3928 | |
3929 | |
3930 | |
3931 | |
3932 | llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT, |
3933 | ArrayRef<const ObjCMethodDecl *> methods) { |
3934 | StringRef prefix; |
3935 | StringRef section; |
3936 | bool forProtocol = false; |
3937 | switch (MLT) { |
3938 | case MethodListType::CategoryInstanceMethods: |
3939 | prefix = "OBJC_CATEGORY_INSTANCE_METHODS_"; |
3940 | section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; |
3941 | forProtocol = false; |
3942 | break; |
3943 | case MethodListType::CategoryClassMethods: |
3944 | prefix = "OBJC_CATEGORY_CLASS_METHODS_"; |
3945 | section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; |
3946 | forProtocol = false; |
3947 | break; |
3948 | case MethodListType::InstanceMethods: |
3949 | prefix = "OBJC_INSTANCE_METHODS_"; |
3950 | section = "__OBJC,__inst_meth,regular,no_dead_strip"; |
3951 | forProtocol = false; |
3952 | break; |
3953 | case MethodListType::ClassMethods: |
3954 | prefix = "OBJC_CLASS_METHODS_"; |
3955 | section = "__OBJC,__cls_meth,regular,no_dead_strip"; |
3956 | forProtocol = false; |
3957 | break; |
3958 | case MethodListType::ProtocolInstanceMethods: |
3959 | prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_"; |
3960 | section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; |
3961 | forProtocol = true; |
3962 | break; |
3963 | case MethodListType::ProtocolClassMethods: |
3964 | prefix = "OBJC_PROTOCOL_CLASS_METHODS_"; |
3965 | section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; |
3966 | forProtocol = true; |
3967 | break; |
3968 | case MethodListType::OptionalProtocolInstanceMethods: |
3969 | prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_"; |
3970 | section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; |
3971 | forProtocol = true; |
3972 | break; |
3973 | case MethodListType::OptionalProtocolClassMethods: |
3974 | prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_"; |
3975 | section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; |
3976 | forProtocol = true; |
3977 | break; |
3978 | } |
3979 | |
3980 | |
3981 | if (methods.empty()) |
3982 | return llvm::Constant::getNullValue(forProtocol |
3983 | ? ObjCTypes.MethodDescriptionListPtrTy |
3984 | : ObjCTypes.MethodListPtrTy); |
3985 | |
3986 | |
3987 | |
3988 | if (forProtocol) { |
3989 | ConstantInitBuilder builder(CGM); |
3990 | auto values = builder.beginStruct(); |
3991 | values.addInt(ObjCTypes.IntTy, methods.size()); |
3992 | auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy); |
3993 | for (auto MD : methods) { |
3994 | emitMethodDescriptionConstant(methodArray, MD); |
3995 | } |
3996 | methodArray.finishAndAddTo(values); |
3997 | |
3998 | llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section, |
3999 | CGM.getPointerAlign(), true); |
4000 | return llvm::ConstantExpr::getBitCast(GV, |
4001 | ObjCTypes.MethodDescriptionListPtrTy); |
4002 | } |
4003 | |
4004 | |
4005 | ConstantInitBuilder builder(CGM); |
4006 | auto values = builder.beginStruct(); |
4007 | values.addNullPointer(ObjCTypes.Int8PtrTy); |
4008 | values.addInt(ObjCTypes.IntTy, methods.size()); |
4009 | auto methodArray = values.beginArray(ObjCTypes.MethodTy); |
4010 | for (auto MD : methods) { |
4011 | if (!MD->isDirectMethod()) |
4012 | emitMethodConstant(methodArray, MD); |
4013 | } |
4014 | methodArray.finishAndAddTo(values); |
4015 | |
4016 | llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section, |
4017 | CGM.getPointerAlign(), true); |
4018 | return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy); |
4019 | } |
4020 | |
4021 | llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD, |
4022 | const ObjCContainerDecl *CD) { |
4023 | llvm::Function *Method; |
4024 | |
4025 | if (OMD->isDirectMethod()) { |
4026 | Method = GenerateDirectMethod(OMD, CD); |
4027 | } else { |
4028 | auto Name = getSymbolNameForMethod(OMD); |
4029 | |
4030 | CodeGenTypes &Types = CGM.getTypes(); |
4031 | llvm::FunctionType *MethodTy = |
4032 | Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD)); |
4033 | Method = |
4034 | llvm::Function::Create(MethodTy, llvm::GlobalValue::InternalLinkage, |
4035 | Name, &CGM.getModule()); |
4036 | } |
4037 | |
4038 | MethodDefinitions.insert(std::make_pair(OMD, Method)); |
4039 | |
4040 | return Method; |
4041 | } |
4042 | |
4043 | llvm::Function * |
4044 | CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD, |
4045 | const ObjCContainerDecl *CD) { |
4046 | auto *COMD = OMD->getCanonicalDecl(); |
4047 | auto I = DirectMethodDefinitions.find(COMD); |
4048 | llvm::Function *OldFn = nullptr, *Fn = nullptr; |
4049 | |
4050 | if (I != DirectMethodDefinitions.end()) { |
4051 | |
4052 | |
4053 | |
4054 | |
4055 | |
4056 | |
4057 | |
4058 | |
4059 | |
4060 | if (!OMD->getBody() || COMD->getReturnType() == OMD->getReturnType()) |
4061 | return I->second; |
4062 | OldFn = I->second; |
4063 | } |
4064 | |
4065 | CodeGenTypes &Types = CGM.getTypes(); |
4066 | llvm::FunctionType *MethodTy = |
4067 | Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD)); |
4068 | |
4069 | if (OldFn) { |
4070 | Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage, |
4071 | "", &CGM.getModule()); |
4072 | Fn->takeName(OldFn); |
4073 | OldFn->replaceAllUsesWith( |
4074 | llvm::ConstantExpr::getBitCast(Fn, OldFn->getType())); |
4075 | OldFn->eraseFromParent(); |
4076 | |
4077 | |
4078 | I->second = Fn; |
4079 | } else { |
4080 | auto Name = getSymbolNameForMethod(OMD, false); |
4081 | |
4082 | Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage, |
4083 | Name, &CGM.getModule()); |
4084 | DirectMethodDefinitions.insert(std::make_pair(COMD, Fn)); |
4085 | } |
4086 | |
4087 | return Fn; |
4088 | } |
4089 | |
4090 | void CGObjCCommonMac::GenerateDirectMethodPrologue( |
4091 | CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD, |
4092 | const ObjCContainerDecl *CD) { |
4093 | auto &Builder = CGF.Builder; |
4094 | bool ReceiverCanBeNull = true; |
4095 | auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl()); |
4096 | auto selfValue = Builder.CreateLoad(selfAddr); |
4097 | |
4098 | |
4099 | |
4100 | |
4101 | |
4102 | |
4103 | |
4104 | |
4105 | |
4106 | |
4107 | |
4108 | |
4109 | |
4110 | |
4111 | if (OMD->isClassMethod()) { |
4112 | const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD); |
4113 | assert(OID && |
4114 | "GenerateDirectMethod() should be called with the Class Interface"); |
4115 | Selector SelfSel = GetNullarySelector("self", CGM.getContext()); |
4116 | auto ResultType = CGF.getContext().getObjCIdType(); |
4117 | RValue result; |
4118 | CallArgList Args; |
4119 | |
4120 | |
4121 | |
4122 | |
4123 | |
4124 | |
4125 | |
4126 | |
4127 | result = GeneratePossiblySpecializedMessageSend( |
4128 | CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID, |
4129 | nullptr, true); |
4130 | Builder.CreateStore(result.getScalarVal(), selfAddr); |
4131 | |
4132 | |
4133 | |
4134 | |
4135 | ReceiverCanBeNull = isWeakLinkedClass(OID); |
4136 | } |
4137 | |
4138 | if (ReceiverCanBeNull) { |
4139 | llvm::BasicBlock *SelfIsNilBlock = |
4140 | CGF.createBasicBlock("objc_direct_method.self_is_nil"); |
4141 | llvm::BasicBlock *ContBlock = |
4142 | CGF.createBasicBlock("objc_direct_method.cont"); |
4143 | |
4144 | |
4145 | auto selfTy = cast<llvm::PointerType>(selfValue->getType()); |
4146 | auto Zero = llvm::ConstantPointerNull::get(selfTy); |
4147 | |
4148 | llvm::MDBuilder MDHelper(CGM.getLLVMContext()); |
4149 | Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock, |
4150 | ContBlock, MDHelper.createBranchWeights(1, 1 << 20)); |
4151 | |
4152 | CGF.EmitBlock(SelfIsNilBlock); |
4153 | |
4154 | |
4155 | auto retTy = OMD->getReturnType(); |
4156 | Builder.SetInsertPoint(SelfIsNilBlock); |
4157 | if (!retTy->isVoidType()) { |
4158 | CGF.EmitNullInitialization(CGF.ReturnValue, retTy); |
4159 | } |
4160 | CGF.EmitBranchThroughCleanup(CGF.ReturnBlock); |
4161 | |
4162 | |
4163 | |
4164 | CGF.EmitBlock(ContBlock); |
4165 | Builder.SetInsertPoint(ContBlock); |
4166 | } |
4167 | |
4168 | |
4169 | if (OMD->getCmdDecl()->isUsed()) { |
4170 | Builder.CreateStore(GetSelector(CGF, OMD), |
4171 | CGF.GetAddrOfLocalVar(OMD->getCmdDecl())); |
4172 | } |
4173 | } |
4174 | |
4175 | llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name, |
4176 | ConstantStructBuilder &Init, |
4177 | StringRef Section, |
4178 | CharUnits Align, |
4179 | bool AddToUsed) { |
4180 | llvm::GlobalValue::LinkageTypes LT = |
4181 | getLinkageTypeForObjCMetadata(CGM, Section); |
4182 | llvm::GlobalVariable *GV = |
4183 | Init.finishAndCreateGlobal(Name, Align, false, LT); |
4184 | if (!Section.empty()) |
4185 | GV->setSection(Section); |
4186 | if (AddToUsed) |
4187 | CGM.addCompilerUsedGlobal(GV); |
4188 | return GV; |
4189 | } |
4190 | |
4191 | llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name, |
4192 | llvm::Constant *Init, |
4193 | StringRef Section, |
4194 | CharUnits Align, |
4195 | bool AddToUsed) { |
4196 | llvm::Type *Ty = Init->getType(); |
4197 | llvm::GlobalValue::LinkageTypes LT = |
4198 | getLinkageTypeForObjCMetadata(CGM, Section); |
4199 | llvm::GlobalVariable *GV = |
4200 | new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name); |
4201 | if (!Section.empty()) |
4202 | GV->setSection(Section); |
4203 | GV->setAlignment(Align.getAsAlign()); |
4204 | if (AddToUsed) |
4205 | CGM.addCompilerUsedGlobal(GV); |
4206 | return GV; |
4207 | } |
4208 | |
4209 | llvm::GlobalVariable * |
4210 | CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type, |
4211 | bool ForceNonFragileABI, |
4212 | bool NullTerminate) { |
4213 | StringRef Label; |
4214 | switch (Type) { |
4215 | case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break; |
4216 | case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break; |
4217 | case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break; |
4218 | case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break; |
4219 | } |
4220 | |
4221 | bool NonFragile = ForceNonFragileABI || isNonFragileABI(); |
4222 | |
4223 | StringRef Section; |
4224 | switch (Type) { |
4225 | case ObjCLabelType::ClassName: |
4226 | Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals" |
4227 | : "__TEXT,__cstring,cstring_literals"; |
4228 | break; |
4229 | case ObjCLabelType::MethodVarName: |
4230 | Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals" |
4231 | : "__TEXT,__cstring,cstring_literals"; |
4232 | break; |
4233 | case ObjCLabelType::MethodVarType: |
4234 | Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals" |
4235 | : "__TEXT,__cstring,cstring_literals"; |
4236 | break; |
4237 | case ObjCLabelType::PropertyName: |
4238 | Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals" |
4239 | : "__TEXT,__cstring,cstring_literals"; |
4240 | break; |
4241 | } |
4242 | |
4243 | llvm::Constant *Value = |
4244 | llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate); |
4245 | llvm::GlobalVariable *GV = |
4246 | new llvm::GlobalVariable(CGM.getModule(), Value->getType(), |
4247 | true, |
4248 | llvm::GlobalValue::PrivateLinkage, Value, Label); |
4249 | if (CGM.getTriple().isOSBinFormatMachO()) |
4250 | GV->setSection(Section); |
4251 | GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); |
4252 | GV->setAlignment(CharUnits::One().getAsAlign()); |
4253 | CGM.addCompilerUsedGlobal(GV); |
4254 | |
4255 | return GV; |
4256 | } |
4257 | |
4258 | llvm::Function *CGObjCMac::ModuleInitFunction() { |
4259 | |
4260 | FinishModule(); |
4261 | return nullptr; |
4262 | } |
4263 | |
4264 | llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() { |
4265 | return ObjCTypes.getGetPropertyFn(); |
4266 | } |
4267 | |
4268 | llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() { |
4269 | return ObjCTypes.getSetPropertyFn(); |
4270 | } |
4271 | |
4272 | llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic, |
4273 | bool copy) { |
4274 | return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy); |
4275 | } |
4276 | |
4277 | llvm::FunctionCallee CGObjCMac::GetGetStructFunction() { |
4278 | return ObjCTypes.getCopyStructFn(); |
4279 | } |
4280 | |
4281 | llvm::FunctionCallee CGObjCMac::GetSetStructFunction() { |
4282 | return ObjCTypes.getCopyStructFn(); |
4283 | } |
4284 | |
4285 | llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() { |
4286 | return ObjCTypes.getCppAtomicObjectFunction(); |
4287 | } |
4288 | |
4289 | llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() { |
4290 | return ObjCTypes.getCppAtomicObjectFunction(); |
4291 | } |
4292 | |
4293 | llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() { |
4294 | return ObjCTypes.getEnumerationMutationFn(); |
4295 | } |
4296 | |
4297 | void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) { |
4298 | return EmitTryOrSynchronizedStmt(CGF, S); |
| 1 | Calling 'CGObjCMac::EmitTryOrSynchronizedStmt' | |
|
4299 | } |
4300 | |
4301 | void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF, |
4302 | const ObjCAtSynchronizedStmt &S) { |
4303 | return EmitTryOrSynchronizedStmt(CGF, S); |
4304 | } |
4305 | |
4306 | namespace { |
4307 | struct PerformFragileFinally final : EHScopeStack::Cleanup { |
4308 | const Stmt &S; |
4309 | Address SyncArgSlot; |
4310 | Address CallTryExitVar; |
4311 | Address ExceptionData; |
4312 | ObjCTypesHelper &ObjCTypes; |
4313 | PerformFragileFinally(const Stmt *S, |
4314 | Address SyncArgSlot, |
4315 | Address CallTryExitVar, |
4316 | Address ExceptionData, |
4317 | ObjCTypesHelper *ObjCTypes) |
4318 | : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar), |
4319 | ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {} |
4320 | |
4321 | void Emit(CodeGenFunction &CGF, Flags flags) override { |
4322 | |
4323 | |
4324 | llvm::BasicBlock *FinallyCallExit = |
4325 | CGF.createBasicBlock("finally.call_exit"); |
4326 | llvm::BasicBlock *FinallyNoCallExit = |
4327 | CGF.createBasicBlock("finally.no_call_exit"); |
4328 | CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar), |
4329 | FinallyCallExit, FinallyNoCallExit); |
4330 | |
4331 | CGF.EmitBlock(FinallyCallExit); |
4332 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(), |
4333 | ExceptionData.getPointer()); |
4334 | |
4335 | CGF.EmitBlock(FinallyNoCallExit); |
4336 | |
4337 | if (isa<ObjCAtTryStmt>(S)) { |
4338 | if (const ObjCAtFinallyStmt* FinallyStmt = |
4339 | cast<ObjCAtTryStmt>(S).getFinallyStmt()) { |
4340 | |
4341 | if (flags.isForEHCleanup()) return; |
4342 | |
4343 | |
4344 | |
4345 | llvm::Value *CurCleanupDest = |
4346 | CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot()); |
4347 | |
4348 | CGF.EmitStmt(FinallyStmt->getFinallyBody()); |
4349 | |
4350 | if (CGF.HaveInsertPoint()) { |
4351 | CGF.Builder.CreateStore(CurCleanupDest, |
4352 | CGF.getNormalCleanupDestSlot()); |
4353 | } else { |
4354 | |
4355 | CGF.EnsureInsertPoint(); |
4356 | } |
4357 | } |
4358 | } else { |
4359 | |
4360 | |
4361 | llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot); |
4362 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg); |
4363 | } |
4364 | } |
4365 | }; |
4366 | |
4367 | class FragileHazards { |
4368 | CodeGenFunction &CGF; |
4369 | SmallVector<llvm::Value*, 20> Locals; |
4370 | llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry; |
4371 | |
4372 | llvm::InlineAsm *ReadHazard; |
4373 | llvm::InlineAsm *WriteHazard; |
4374 | |
4375 | llvm::FunctionType *GetAsmFnType(); |
4376 | |
4377 | void collectLocals(); |
4378 | void emitReadHazard(CGBuilderTy &Builder); |
4379 | |
4380 | public: |
4381 | FragileHazards(CodeGenFunction &CGF); |
4382 | |
4383 | void emitWriteHazard(); |
4384 | void emitHazardsInNewBlocks(); |
4385 | }; |
4386 | } |
4387 | |
4388 | |
4389 | |
4390 | |
4391 | |
4392 | |
4393 | FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) { |
4394 | collectLocals(); |
4395 | |
4396 | if (Locals.empty()) return; |
4397 | |
4398 | |
4399 | for (llvm::Function::iterator |
4400 | I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I) |
4401 | BlocksBeforeTry.insert(&*I); |
4402 | |
4403 | llvm::FunctionType *AsmFnTy = GetAsmFnType(); |
4404 | |
4405 | |
4406 | |
4407 | |
4408 | |
4409 | |
4410 | { |
4411 | std::string Constraint; |
4412 | for (unsigned I = 0, E = Locals.size(); I != E; ++I) { |
4413 | if (I) Constraint += ','; |
4414 | Constraint += "*m"; |
4415 | } |
4416 | |
4417 | ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false); |
4418 | } |
4419 | |
4420 | |
4421 | |
4422 | |
4423 | |
4424 | { |
4425 | std::string Constraint; |
4426 | for (unsigned I = 0, E = Locals.size(); I != E; ++I) { |
4427 | if (I) Constraint += ','; |
4428 | Constraint += "=*m"; |
4429 | } |
4430 | |
4431 | WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false); |
4432 | } |
4433 | } |
4434 | |
4435 | |
4436 | void FragileHazards::emitWriteHazard() { |
4437 | if (Locals.empty()) return; |
4438 | |
4439 | CGF.EmitNounwindRuntimeCall(WriteHazard, Locals); |
4440 | } |
4441 | |
4442 | void FragileHazards::emitReadHazard(CGBuilderTy &Builder) { |
4443 | assert(!Locals.empty()); |
4444 | llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals); |
4445 | call->setDoesNotThrow(); |
4446 | call->setCallingConv(CGF.getRuntimeCC()); |
4447 | } |
4448 | |
4449 | |
4450 | |
4451 | void FragileHazards::emitHazardsInNewBlocks() { |
4452 | if (Locals.empty()) return; |
4453 | |
4454 | CGBuilderTy Builder(CGF, CGF.getLLVMContext()); |
4455 | |
4456 | |
4457 | for (llvm::Function::iterator |
4458 | FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) { |
4459 | llvm::BasicBlock &BB = *FI; |
4460 | if (BlocksBeforeTry.count(&BB)) continue; |
4461 | |
4462 | |
4463 | for (llvm::BasicBlock::iterator |
4464 | BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) { |
4465 | llvm::Instruction &I = *BI; |
4466 | |
4467 | |
4468 | |
4469 | if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) |
4470 | continue; |
4471 | if (isa<llvm::IntrinsicInst>(I)) |
4472 | continue; |
4473 | |
4474 | |
4475 | |
4476 | if (cast<llvm::CallBase>(I).doesNotThrow()) |
4477 | continue; |
4478 | |
4479 | |
4480 | |
4481 | |
4482 | |
4483 | |
4484 | Builder.SetInsertPoint(&BB, BI); |
4485 | emitReadHazard(Builder); |
4486 | } |
4487 | } |
4488 | } |
4489 | |
4490 | static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) { |
4491 | if (V.isValid()) S.insert(V.getPointer()); |
4492 | } |
4493 | |
4494 | void FragileHazards::collectLocals() { |
4495 | |
4496 | llvm::DenseSet<llvm::Value*> AllocasToIgnore; |
4497 | addIfPresent(AllocasToIgnore, CGF.ReturnValue); |
4498 | addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest); |
4499 | |
4500 | |
4501 | |
4502 | llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock(); |
4503 | for (llvm::BasicBlock::iterator |
4504 | I = Entry.begin(), E = Entry.end(); I != E; ++I) |
4505 | if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I)) |
4506 | Locals.push_back(&*I); |
4507 | } |
4508 | |
4509 | llvm::FunctionType *FragileHazards::GetAsmFnType() { |
4510 | SmallVector<llvm::Type *, 16> tys(Locals.size()); |
4511 | for (unsigned i = 0, e = Locals.size(); i != e; ++i) |
4512 | tys[i] = Locals[i]->getType(); |
4513 | return llvm::FunctionType::get(CGF.VoidTy, tys, false); |
4514 | } |
4515 | |
4516 | |
4517 | |
4518 | |
4519 | |
4520 | |
4521 | |
4522 | |
4523 | |
4524 | |
4525 | |
4526 | |
4527 | |
4528 | |
4529 | |
4530 | |
4531 | |
4532 | |
4533 | |
4534 | |
4535 | |
4536 | |
4537 | |
4538 | |
4539 | |
4540 | |
4541 | |
4542 | |
4543 | |
4544 | |
4545 | |
4546 | |
4547 | |
4548 | |
4549 | |
4550 | |
4551 | |
4552 | |
4553 | |
4554 | |
4555 | |
4556 | |
4557 | |
4558 | |
4559 | |
4560 | |
4561 | |
4562 | |
4563 | |
4564 | |
4565 | |
4566 | |
4567 | |
4568 | |
4569 | |
4570 | |
4571 | |
4572 | |
4573 | |
4574 | |
4575 | |
4576 | |
4577 | |
4578 | |
4579 | |
4580 | |
4581 | |
4582 | |
4583 | |
4584 | |
4585 | |
4586 | |
4587 | |
4588 | |
4589 | |
4590 | |
4591 | |
4592 | |
4593 | |
4594 | |
4595 | |
4596 | |
4597 | |
4598 | |
4599 | |
4600 | |
4601 | |
4602 | |
4603 | |
4604 | |
4605 | |
4606 | |
4607 | |
4608 | |
4609 | |
4610 | |
4611 | |
4612 | |
4613 | |
4614 | |
4615 | |
4616 | |
4617 | |
4618 | |
4619 | |
4620 | |
4621 | |
4622 | |
4623 | |
4624 | |
4625 | |
4626 | |
4627 | |
4628 | void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, |
4629 | const Stmt &S) { |
4630 | bool isTry = isa<ObjCAtTryStmt>(S); |
| 2 | | Assuming 'S' is a 'ObjCAtTryStmt' | |
|
4631 | |
4632 | |
4633 | |
4634 | CodeGenFunction::JumpDest FinallyEnd = |
4635 | CGF.getJumpDestInCurrentScope("finally.end"); |
4636 | |
4637 | |
4638 | |
4639 | CodeGenFunction::JumpDest FinallyRethrow = |
4640 | CGF.getJumpDestInCurrentScope("finally.rethrow"); |
4641 | |
4642 | |
4643 | |
4644 | |
4645 | |
4646 | |
4647 | Address SyncArgSlot = Address::invalid(); |
4648 | if (!isTry) { |
| |
4649 | llvm::Value *SyncArg = |
4650 | CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr()); |
4651 | SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy); |
4652 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg); |
4653 | |
4654 | SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(), |
4655 | CGF.getPointerAlign(), "sync.arg"); |
4656 | CGF.Builder.CreateStore(SyncArg, SyncArgSlot); |
4657 | } |
4658 | |
4659 | |
4660 | |
4661 | Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy, |
4662 | CGF.getPointerAlign(), |
4663 | "exceptiondata.ptr"); |
4664 | |
4665 | |
4666 | |
4667 | |
4668 | |
4669 | FragileHazards Hazards(CGF); |
4670 | |
4671 | |
4672 | |
4673 | |
4674 | |
4675 | |
4676 | |
4677 | |
4678 | |
4679 | Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), |
4680 | CharUnits::One(), |
4681 | "_call_try_exit"); |
4682 | |
4683 | |
4684 | |
4685 | Address PropagatingExnVar = Address::invalid(); |
4686 | |
4687 | |
4688 | CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S, |
4689 | SyncArgSlot, |
4690 | CallTryExitVar, |
4691 | ExceptionData, |
4692 | &ObjCTypes); |
4693 | |
4694 | |
4695 | |
4696 | |
4697 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(), |
4698 | ExceptionData.getPointer()); |
4699 | |
4700 | |
4701 | llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0); |
4702 | llvm::Value *GEPIndexes[] = { Zero, Zero, Zero }; |
4703 | llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP( |
4704 | ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes, |
4705 | "setjmp_buffer"); |
4706 | llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall( |
4707 | ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result"); |
4708 | SetJmpResult->setCanReturnTwice(); |
4709 | |
4710 | |
4711 | |
4712 | llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try"); |
4713 | llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler"); |
4714 | llvm::Value *DidCatch = |
4715 | CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception"); |
4716 | CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock); |
4717 | |
4718 | |
4719 | CGF.EmitBlock(TryBlock); |
4720 | CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar); |
4721 | CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody() |
| |
| 5 | | 'S' is a 'ObjCAtTryStmt' | |
|
4722 | : cast<ObjCAtSynchronizedStmt>(S).getSynchBody()); |
4723 | |
4724 | CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP(); |
4725 | |
4726 | |
4727 | CGF.EmitBlock(TryHandler); |
4728 | |
4729 | |
4730 | Hazards.emitWriteHazard(); |
4731 | |
4732 | |
4733 | |
4734 | if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) { |
| 6 | | 'S' is a 'ObjCAtTryStmt' | |
|
| 7 | | Assuming the condition is false | |
|
| |
4735 | |
4736 | CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar); |
4737 | CGF.EmitBranchThroughCleanup(FinallyRethrow); |
4738 | |
4739 | |
4740 | } else { |
4741 | |
4742 | |
4743 | llvm::CallInst *Caught = |
4744 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(), |
4745 | ExceptionData.getPointer(), "caught"); |
4746 | |
4747 | |
4748 | |
4749 | CGF.ObjCEHValueStack.push_back(Caught); |
4750 | |
4751 | const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S); |
| 9 | | The object is a 'ObjCAtTryStmt' | |
|
4752 | |
4753 | bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr); |
4754 | |
4755 | llvm::BasicBlock *CatchBlock = nullptr; |
4756 | llvm::BasicBlock *CatchHandler = nullptr; |
4757 | if (HasFinally) { |
| |
4758 | |
4759 | |
4760 | PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(), |
4761 | CGF.getPointerAlign(), |
4762 | "propagating_exception"); |
4763 | CGF.Builder.CreateStore(Caught, PropagatingExnVar); |
4764 | |
4765 | |
4766 | |
4767 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(), |
4768 | ExceptionData.getPointer()); |
4769 | |
4770 | llvm::CallInst *SetJmpResult = |
4771 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(), |
4772 | SetJmpBuffer, "setjmp.result"); |
4773 | SetJmpResult->setCanReturnTwice(); |
4774 | |
4775 | llvm::Value *Threw = |
4776 | CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception"); |
4777 | |
4778 | CatchBlock = CGF.createBasicBlock("catch"); |
4779 | CatchHandler = CGF.createBasicBlock("catch_for_catch"); |
4780 | CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock); |
4781 | |
4782 | CGF.EmitBlock(CatchBlock); |
4783 | } |
4784 | |
4785 | CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar); |
4786 | |
4787 | |
4788 | |
4789 | |
4790 | bool AllMatched = false; |
4791 | for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) { |
| 11 | | Loop condition is true. Entering loop body | |
|
4792 | const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I); |
4793 | |
4794 | const VarDecl *CatchParam = CatchStmt->getCatchParamDecl(); |
4795 | const ObjCObjectPointerType *OPT = nullptr; |
4796 | |
4797 | |
4798 | if (!CatchParam) { |
| 12 | | Assuming 'CatchParam' is non-null | |
|
| |
4799 | AllMatched = true; |
4800 | } else { |
4801 | OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>(); |
| 14 | | Assuming the object is not a 'ObjCObjectPointerType' | |
|
| 15 | | Null pointer value stored to 'OPT' | |
|
4802 | |
4803 | |
4804 | |
4805 | |
4806 | |
4807 | if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType())) |
4808 | AllMatched = true; |
4809 | } |
4810 | |
4811 | |
4812 | if (AllMatched) { |
| |
4813 | CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF); |
4814 | |
4815 | if (CatchParam) { |
4816 | CGF.EmitAutoVarDecl(*CatchParam); |
4817 | assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); |
4818 | |
4819 | |
4820 | EmitInitOfCatchParam(CGF, Caught, CatchParam); |
4821 | } |
4822 | |
4823 | CGF.EmitStmt(CatchStmt->getCatchBody()); |
4824 | |
4825 | |
4826 | CatchVarCleanups.ForceCleanup(); |
4827 | |
4828 | CGF.EmitBranchThroughCleanup(FinallyEnd); |
4829 | break; |
4830 | } |
4831 | |
4832 | assert(OPT && "Unexpected non-object pointer type in @catch"); |
4833 | const ObjCObjectType *ObjTy = OPT->getObjectType(); |
| 17 | | Called C++ object pointer is null |
|
4834 | |
4835 | |
4836 | ObjCInterfaceDecl *IDecl = ObjTy->getInterface(); |
4837 | assert(IDecl && "Catch parameter must have Objective-C type!"); |
4838 | |
4839 | |
4840 | llvm::Value *Class = EmitClassRef(CGF, IDecl); |
4841 | |
4842 | llvm::Value *matchArgs[] = { Class, Caught }; |
4843 | llvm::CallInst *Match = |
4844 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(), |
4845 | matchArgs, "match"); |
4846 | |
4847 | llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match"); |
4848 | llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next"); |
4849 | |
4850 | CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"), |
4851 | MatchedBlock, NextCatchBlock); |
4852 | |
4853 | |
4854 | CGF.EmitBlock(MatchedBlock); |
4855 | |
4856 | |
4857 | |
4858 | CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF); |
4859 | |
4860 | CGF.EmitAutoVarDecl(*CatchParam); |
4861 | assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); |
4862 | |
4863 | |
4864 | llvm::Value *Tmp = |
4865 | CGF.Builder.CreateBitCast(Caught, |
4866 | CGF.ConvertType(CatchParam->getType())); |
4867 | EmitInitOfCatchParam(CGF, Tmp, CatchParam); |
4868 | |
4869 | CGF.EmitStmt(CatchStmt->getCatchBody()); |
4870 | |
4871 | |
4872 | CatchVarCleanups.ForceCleanup(); |
4873 | |
4874 | CGF.EmitBranchThroughCleanup(FinallyEnd); |
4875 | |
4876 | CGF.EmitBlock(NextCatchBlock); |
4877 | } |
4878 | |
4879 | CGF.ObjCEHValueStack.pop_back(); |
4880 | |
4881 | |
4882 | |
4883 | if (Caught->use_empty()) |
4884 | Caught->eraseFromParent(); |
4885 | |
4886 | if (!AllMatched) |
4887 | CGF.EmitBranchThroughCleanup(FinallyRethrow); |
4888 | |
4889 | if (HasFinally) { |
4890 | |
4891 | CGF.EmitBlock(CatchHandler); |
4892 | |
4893 | |
4894 | |
4895 | |
4896 | |
4897 | |
4898 | |
4899 | |
4900 | assert(PropagatingExnVar.isValid()); |
4901 | llvm::CallInst *NewCaught = |
4902 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(), |
4903 | ExceptionData.getPointer(), "caught"); |
4904 | CGF.Builder.CreateStore(NewCaught, PropagatingExnVar); |
4905 | |
4906 | |
4907 | CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar); |
4908 | CGF.EmitBranchThroughCleanup(FinallyRethrow); |
4909 | } |
4910 | } |
4911 | |
4912 | |
4913 | Hazards.emitHazardsInNewBlocks(); |
4914 | |
4915 | |
4916 | CGF.Builder.restoreIP(TryFallthroughIP); |
4917 | if (CGF.HaveInsertPoint()) |
4918 | CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar); |
4919 | CGF.PopCleanupBlock(); |
4920 | CGF.EmitBlock(FinallyEnd.getBlock(), true); |
4921 | |
4922 | |
4923 | CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); |
4924 | CGF.EmitBlock(FinallyRethrow.getBlock(), true); |
4925 | if (CGF.HaveInsertPoint()) { |
4926 | |
4927 | llvm::Value *PropagatingExn; |
4928 | if (PropagatingExnVar.isValid()) { |
4929 | PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar); |
4930 | |
4931 | |
4932 | } else { |
4933 | llvm::CallInst *Caught = |
4934 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(), |
4935 | ExceptionData.getPointer()); |
4936 | PropagatingExn = Caught; |
4937 | } |
4938 | |
4939 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(), |
4940 | PropagatingExn); |
4941 | CGF.Builder.CreateUnreachable(); |
4942 | } |
4943 | |
4944 | CGF.Builder.restoreIP(SavedIP); |
4945 | } |
4946 | |
4947 | void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, |
4948 | const ObjCAtThrowStmt &S, |
4949 | bool ClearInsertionPoint) { |
4950 | llvm::Value *ExceptionAsObject; |
4951 | |
4952 | if (const Expr *ThrowExpr = S.getThrowExpr()) { |
4953 | llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr); |
4954 | ExceptionAsObject = |
4955 | CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy); |
4956 | } else { |
4957 | assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && |
4958 | "Unexpected rethrow outside @catch block."); |
4959 | ExceptionAsObject = CGF.ObjCEHValueStack.back(); |
4960 | } |
4961 | |
4962 | CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject) |
4963 | ->setDoesNotReturn(); |
4964 | CGF.Builder.CreateUnreachable(); |
4965 | |
4966 | |
4967 | if (ClearInsertionPoint) |
4968 | CGF.Builder.ClearInsertionPoint(); |
4969 | } |
4970 | |
4971 | |
4972 | |
4973 | |
4974 | llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, |
4975 | Address AddrWeakObj) { |
4976 | llvm::Type* DestTy = AddrWeakObj.getElementType(); |
4977 | AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, |
4978 | ObjCTypes.PtrObjectPtrTy); |
4979 | llvm::Value *read_weak = |
4980 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(), |
4981 | AddrWeakObj.getPointer(), "weakread"); |
4982 | read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); |
4983 | return read_weak; |
4984 | } |
4985 | |
4986 | |
4987 | |
4988 | |
4989 | void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, |
4990 | llvm::Value *src, Address dst) { |
4991 | llvm::Type * SrcTy = src->getType(); |
4992 | if (!isa<llvm::PointerType>(SrcTy)) { |
4993 | unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); |
4994 | assert(Size <= 8 && "does not support size > 8"); |
4995 | src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) |
4996 | : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); |
4997 | src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); |
4998 | } |
4999 | src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); |
5000 | dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); |
5001 | llvm::Value *args[] = { src, dst.getPointer() }; |
5002 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(), |
5003 | args, "weakassign"); |
5004 | } |
5005 | |
5006 | |
5007 | |
5008 | |
5009 | void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, |
5010 | llvm::Value *src, Address dst, |
5011 | bool threadlocal) { |
5012 | llvm::Type * SrcTy = src->getType(); |
5013 | if (!isa<llvm::PointerType>(SrcTy)) { |
5014 | unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); |
5015 | assert(Size <= 8 && "does not support size > 8"); |
5016 | src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) |
5017 | : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); |
5018 | src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); |
5019 | } |
5020 | src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); |
5021 | dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); |
5022 | llvm::Value *args[] = { src, dst.getPointer() }; |
5023 | if (!threadlocal) |
5024 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(), |
5025 | args, "globalassign"); |
5026 | else |
5027 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(), |
5028 | args, "threadlocalassign"); |
5029 | } |
5030 | |
5031 | |
5032 | |
5033 | |
5034 | void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, |
5035 | llvm::Value *src, Address dst, |
5036 | llvm::Value *ivarOffset) { |
5037 | assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL"); |
5038 | llvm::Type * SrcTy = src->getType(); |
5039 | if (!isa<llvm::PointerType>(SrcTy)) { |
5040 | unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); |
5041 | assert(Size <= 8 && "does not support size > 8"); |
5042 | src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) |
5043 | : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); |
5044 | src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); |
5045 | } |
5046 | src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); |
5047 | dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); |
5048 | llvm::Value *args[] = { src, dst.getPointer(), ivarOffset }; |
5049 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args); |
5050 | } |
5051 | |
5052 | |
5053 | |
5054 | |
5055 | void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, |
5056 | llvm::Value *src, Address dst) { |
5057 | llvm::Type * SrcTy = src->getType(); |
5058 | if (!isa<llvm::PointerType>(SrcTy)) { |
5059 | unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); |
5060 | assert(Size <= 8 && "does not support size > 8"); |
5061 | src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) |
5062 | : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); |
5063 | src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); |
5064 | } |
5065 | src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); |
5066 | dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); |
5067 | llvm::Value *args[] = { src, dst.getPointer() }; |
5068 | CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(), |
5069 | args, "strongassign"); |
5070 | } |
5071 | |
5072 | void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, |
5073 | Address DestPtr, |
5074 | Address SrcPtr, |
5075 | llvm::Value *size) { |
5076 | SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy); |
5077 | DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy); |
5078 | llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size }; |
5079 | CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args); |
5080 | } |
5081 | |
5082 | |
5083 | |
5084 | LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, |
5085 | QualType ObjectTy, |
5086 | llvm::Value *BaseValue, |
5087 | const ObjCIvarDecl *Ivar, |
5088 | unsigned CVRQualifiers) { |
5089 | const ObjCInterfaceDecl *ID = |
5090 | ObjectTy->castAs<ObjCObjectType>()->getInterface(); |
5091 | return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, |
5092 | EmitIvarOffset(CGF, ID, Ivar)); |
5093 | } |
5094 | |
5095 | llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF, |
5096 | const ObjCInterfaceDecl *Interface, |
5097 | const ObjCIvarDecl *Ivar) { |
5098 | uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar); |
5099 | return llvm::ConstantInt::get( |
5100 | CGM.getTypes().ConvertType(CGM.getContext().LongTy), |
5101 | Offset); |
5102 | } |
5103 | |
5104 | |
5105 | |
5106 | std::string CGObjCCommonMac::GetSectionName(StringRef Section, |
5107 | StringRef MachOAttributes) { |
5108 | switch (CGM.getTriple().getObjectFormat()) { |
5109 | case llvm::Triple::UnknownObjectFormat: |
5110 | llvm_unreachable("unexpected object file format"); |
5111 | case llvm::Triple::MachO: { |
5112 | if (MachOAttributes.empty()) |
5113 | return ("__DATA," + Section).str(); |
5114 | return ("__DATA," + Section + "," + MachOAttributes).str(); |
5115 | } |
5116 | case llvm::Triple::ELF: |
5117 | assert(Section.substr(0, 2) == "__" && |
5118 | "expected the name to begin with __"); |
5119 | return Section.substr(2).str(); |
5120 | case llvm::Triple::COFF: |
5121 | assert(Section.substr(0, 2) == "__" && |
5122 | "expected the name to begin with __"); |
5123 | return ("." + Section.substr(2) + "$B").str(); |
5124 | case llvm::Triple::Wasm: |
5125 | case llvm::Triple::GOFF: |
5126 | case llvm::Triple::XCOFF: |
5127 | llvm::report_fatal_error( |
5128 | "Objective-C support is unimplemented for object file format"); |
5129 | } |
5130 | |
5131 | llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum"); |
5132 | } |
5133 | |
5134 | |
5135 | |
5136 | |
5137 | |
5138 | |
5139 | |
5140 | |
5141 | |
5142 | enum ImageInfoFlags { |
5143 | eImageInfo_FixAndContinue = (1 << 0), |
5144 | eImageInfo_GarbageCollected = (1 << 1), |
5145 | eImageInfo_GCOnly = (1 << 2), |
5146 | eImageInfo_OptimizedByDyld = (1 << 3), |
5147 | |
5148 | |
5149 | |
5150 | eImageInfo_CorrectedSynthesize = (1 << 4), |
5151 | eImageInfo_ImageIsSimulated = (1 << 5), |
5152 | eImageInfo_ClassProperties = (1 << 6) |
5153 | }; |
5154 | |
5155 | void CGObjCCommonMac::EmitImageInfo() { |
5156 | unsigned version = 0; |
5157 | std::string Section = |
5158 | (ObjCABI == 1) |
5159 | ? "__OBJC,__image_info,regular" |
5160 | : GetSectionName("__objc_imageinfo", "regular,no_dead_strip"); |
5161 | |
5162 | |
5163 | |
5164 | llvm::Module &Mod = CGM.getModule(); |
5165 | |
5166 | |
5167 | Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI); |
5168 | Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version", |
5169 | version); |
5170 | Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section", |
5171 | llvm::MDString::get(VMContext, Section)); |
5172 | |
5173 | auto Int8Ty = llvm::Type::getInt8Ty(VMContext); |
5174 | if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { |
5175 | |
5176 | Mod.addModuleFlag(llvm::Module::Error, |
5177 | "Objective-C Garbage Collection", |
5178 | llvm::ConstantInt::get(Int8Ty,0)); |
5179 | } else { |
5180 | |
5181 | Mod.addModuleFlag(llvm::Module::Error, |
5182 | "Objective-C Garbage Collection", |
5183 | llvm::ConstantInt::get(Int8Ty, |
5184 | (uint8_t)eImageInfo_GarbageCollected)); |
5185 | |
5186 | if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) { |
5187 | |
5188 | Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only", |
5189 | eImageInfo_GCOnly); |
5190 | |
5191 | |
5192 | llvm::Metadata *Ops[2] = { |
5193 | llvm::MDString::get(VMContext, "Objective-C Garbage Collection"), |
5194 | llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( |
5195 | Int8Ty, eImageInfo_GarbageCollected))}; |
5196 | Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only", |
5197 | llvm::MDNode::get(VMContext, Ops)); |
5198 | } |
5199 | } |
5200 | |
5201 | |
5202 | if (CGM.getTarget().getTriple().isSimulatorEnvironment()) |
5203 | Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated", |
5204 | eImageInfo_ImageIsSimulated); |
5205 | |
5206 | |
5207 | Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties", |
5208 | eImageInfo_ClassProperties); |
5209 | } |
5210 | |
5211 | |
5212 | |
5213 | |
5214 | |
5215 | |
5216 | |
5217 | |
5218 | |
5219 | static const int ModuleVersion = 7; |
5220 | |
5221 | void CGObjCMac::EmitModuleInfo() { |
5222 | uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy); |
5223 | |
5224 | ConstantInitBuilder builder(CGM); |
5225 | auto values = builder.beginStruct(ObjCTypes.ModuleTy); |
5226 | values.addInt(ObjCTypes.LongTy, ModuleVersion); |
5227 | values.addInt(ObjCTypes.LongTy, Size); |
5228 | |
5229 | values.add(GetClassName(StringRef(""))); |
5230 | values.add(EmitModuleSymbols()); |
5231 | CreateMetadataVar("OBJC_MODULES", values, |
5232 | "__OBJC,__module_info,regular,no_dead_strip", |
5233 | CGM.getPointerAlign(), true); |
5234 | } |
5235 | |
5236 | llvm::Constant *CGObjCMac::EmitModuleSymbols() { |
5237 | unsigned NumClasses = DefinedClasses.size(); |
5238 | unsigned NumCategories = DefinedCategories.size(); |
5239 | |
5240 | |
5241 | if (!NumClasses && !NumCategories) |
5242 | return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy); |
5243 | |
5244 | ConstantInitBuilder builder(CGM); |
5245 | auto values = builder.beginStruct(); |
5246 | values.addInt(ObjCTypes.LongTy, 0); |
5247 | values.addNullPointer(ObjCTypes.SelectorPtrTy); |
5248 | values.addInt(ObjCTypes.ShortTy, NumClasses); |
5249 | values.addInt(ObjCTypes.ShortTy, NumCategories); |
5250 | |
5251 | |
5252 | |
5253 | auto array = values.beginArray(ObjCTypes.Int8PtrTy); |
5254 | for (unsigned i=0; i<NumClasses; i++) { |
5255 | const ObjCInterfaceDecl *ID = ImplementedClasses[i]; |
5256 | assert(ID); |
5257 | if (ObjCImplementationDecl *IMP = ID->getImplementation()) |
5258 | |
5259 | if (ID->isWeakImported() && !IMP->isWeakImported()) |
5260 | DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage); |
5261 | |
5262 | array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy); |
5263 | } |
5264 | for (unsigned i=0; i<NumCategories; i++) |
5265 | array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy); |
5266 | |
5267 | array.finishAndAddTo(values); |
5268 | |
5269 | llvm::GlobalVariable *GV = CreateMetadataVar( |
5270 | "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip", |
5271 | CGM.getPointerAlign(), true); |
5272 | return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy); |
5273 | } |
5274 | |
5275 | llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF, |
5276 | IdentifierInfo *II) { |
5277 | LazySymbols.insert(II); |
5278 | |
5279 | llvm::GlobalVariable *&Entry = ClassReferences[II]; |
5280 | |
5281 | if (!Entry) { |
5282 | llvm::Constant *Casted = |
5283 | llvm::ConstantExpr::getBitCast(GetClassName(II->getName()), |
5284 | ObjCTypes.ClassPtrTy); |
5285 | Entry = CreateMetadataVar( |
5286 | "OBJC_CLASS_REFERENCES_", Casted, |
5287 | "__OBJC,__cls_refs,literal_pointers,no_dead_strip", |
5288 | CGM.getPointerAlign(), true); |
5289 | } |
5290 | |
5291 | return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry, |
5292 | CGF.getPointerAlign()); |
5293 | } |
5294 | |
5295 | llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF, |
5296 | const ObjCInterfaceDecl *ID) { |
5297 | |
5298 | |
5299 | if (ID->hasAttr<ObjCRuntimeVisibleAttr>()) |
5300 | return EmitClassRefViaRuntime(CGF, ID, ObjCTypes); |
5301 | |
5302 | IdentifierInfo *RuntimeName = |
5303 | &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString()); |
5304 | return EmitClassRefFromId(CGF, RuntimeName); |
5305 | } |
5306 | |
5307 | llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) { |
5308 | IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool"); |
5309 | return EmitClassRefFromId(CGF, II); |
5310 | } |
5311 | |
5312 | llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) { |
5313 | return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel)); |
5314 | } |
5315 | |
5316 | Address CGObjCMac::EmitSelectorAddr(Selector Sel) { |
5317 | CharUnits Align = CGM.getPointerAlign(); |
5318 | |
5319 | llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; |
5320 | if (!Entry) { |
5321 | llvm::Constant *Casted = |
5322 | llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel), |
5323 | ObjCTypes.SelectorPtrTy); |
5324 | Entry = CreateMetadataVar( |
5325 | "OBJC_SELECTOR_REFERENCES_", Casted, |
5326 | "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true); |
5327 | Entry->setExternallyInitialized(true); |
5328 | } |
5329 | |
5330 | return Address(Entry, Align); |
5331 | } |
5332 | |
5333 | llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) { |
5334 | llvm::GlobalVariable *&Entry = ClassNames[RuntimeName]; |
5335 | if (!Entry) |
5336 | Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName); |
5337 | return getConstantGEP(VMContext, Entry, 0, 0); |
5338 | } |
5339 | |
5340 | llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) { |
5341 | llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator |
5342 | I = MethodDefinitions.find(MD); |
5343 | if (I != MethodDefinitions.end()) |
5344 | return I->second; |
5345 | |
5346 | return nullptr; |
5347 | } |
5348 | |
5349 | |
5350 | |
5351 | llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident, |
5352 | const ObjCCommonTypesHelper &ObjCTypes) { |
5353 | return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); |
5354 | } |
5355 | |
5356 | void IvarLayoutBuilder::visitRecord(const RecordType *RT, |
5357 | CharUnits offset) { |
5358 | const RecordDecl *RD = RT->getDecl(); |
5359 | |
5360 | |
5361 | |
5362 | if (RD->isUnion()) |
5363 | IsDisordered = true; |
5364 | |
5365 | const ASTRecordLayout *recLayout = nullptr; |
5366 | visitAggregate(RD->field_begin(), RD->field_end(), offset, |
5367 | [&](const FieldDecl *field) -> CharUnits { |
5368 | if (!recLayout) |
5369 | recLayout = &CGM.getContext().getASTRecordLayout(RD); |
5370 | auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex()); |
5371 | return CGM.getContext().toCharUnitsFromBits(offsetInBits); |
5372 | }); |
5373 | } |
5374 | |
5375 | template <class Iterator, class GetOffsetFn> |
5376 | void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end, |
5377 | CharUnits aggregateOffset, |
5378 | const GetOffsetFn &getOffset) { |
5379 | for (; begin != end; ++begin) { |
5380 | auto field = *begin; |
5381 | |
5382 | |
5383 | if (field->isBitField()) { |
5384 | continue; |
5385 | } |
5386 | |
5387 | |
5388 | CharUnits fieldOffset = aggregateOffset + getOffset(field); |
5389 | |
5390 | visitField(field, fieldOffset); |
5391 | } |
5392 | } |
5393 | |
5394 | |
5395 | void IvarLayoutBuilder::visitField(const FieldDecl *field, |
5396 | CharUnits fieldOffset) { |
5397 | QualType fieldType = field->getType(); |
5398 | |
5399 | |
5400 | uint64_t numElts = 1; |
5401 | if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) { |
5402 | numElts = 0; |
5403 | fieldType = arrayType->getElementType(); |
5404 | } |
5405 | |
5406 | while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) { |
5407 | numElts *= arrayType->getSize().getZExtValue(); |
5408 | fieldType = arrayType->getElementType(); |
5409 | } |
5410 | |
5411 | assert(!fieldType->isArrayType() && "ivar of non-constant array type?"); |
5412 | |
5413 | |
5414 | |
5415 | if (numElts == 0) return; |
5416 | |
5417 | |
5418 | if (auto recType = fieldType->getAs<RecordType>()) { |
5419 | size_t oldEnd = IvarsInfo.size(); |
5420 | |
5421 | visitRecord(recType, fieldOffset); |
5422 | |
5423 | |
5424 | auto numEltEntries = IvarsInfo.size() - oldEnd; |
5425 | if (numElts != 1 && numEltEntries != 0) { |
5426 | CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType); |
5427 | for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) { |
5428 | |
5429 | |
5430 | for (size_t i = 0; i != numEltEntries; ++i) { |
5431 | auto firstEntry = IvarsInfo[oldEnd + i]; |
5432 | IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize, |
5433 | firstEntry.SizeInWords)); |
5434 | } |
5435 | } |
5436 | } |
5437 | |
5438 | return; |
5439 | } |
5440 | |
5441 | |
5442 | Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType); |
5443 | |
5444 | |
5445 | if ((ForStrongLayout && GCAttr == Qualifiers::Strong) |
5446 | || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) { |
5447 | assert(CGM.getContext().getTypeSizeInChars(fieldType) |
5448 | == CGM.getPointerSize()); |
5449 | IvarsInfo.push_back(IvarInfo(fieldOffset, numElts)); |
5450 | } |
5451 | } |
5452 | |
5453 | |
5454 | |
5455 | |
5456 | llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC, |
5457 | llvm::SmallVectorImpl<unsigned char> &buffer) { |
5458 | |
5459 | |
5460 | const unsigned char MaxNibble = 0xF; |
5461 | const unsigned char SkipMask = 0xF0, SkipShift = 4; |
5462 | const unsigned char ScanMask = 0x0F, ScanShift = 0; |
5463 | |
5464 | assert(!IvarsInfo.empty() && "generating bitmap for no data"); |
5465 | |
5466 | |
5467 | |
5468 | if (IsDisordered) { |
5469 | |
5470 | llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end()); |
5471 | } else { |
5472 | assert(llvm::is_sorted(IvarsInfo)); |
5473 | } |
5474 | assert(IvarsInfo.back().Offset < InstanceEnd); |
5475 | |
5476 | assert(buffer.empty()); |
5477 | |
5478 | |
5479 | auto skip = [&](unsigned numWords) { |
5480 | assert(numWords > 0); |
5481 | |
5482 | |
5483 | |
5484 | if (!buffer.empty() && !(buffer.back() & ScanMask)) { |
5485 | unsigned lastSkip = buffer.back() >> SkipShift; |
5486 | if (lastSkip < MaxNibble) { |
5487 | unsigned claimed = std::min(MaxNibble - lastSkip, numWords); |
5488 | numWords -= claimed; |
5489 | lastSkip += claimed; |
5490 | buffer.back() = (lastSkip << SkipShift); |
5491 | } |
5492 | } |
5493 | |
5494 | while (numWords >= MaxNibble) { |
5495 | buffer.push_back(MaxNibble << SkipShift); |
5496 | numWords -= MaxNibble; |
5497 | } |
5498 | if (numWords) { |
5499 | buffer.push_back(numWords << SkipShift); |
5500 | } |
5501 | }; |
5502 | |
5503 | |
5504 | auto scan = [&](unsigned numWords) { |
5505 | assert(numWords > 0); |
5506 | |
5507 | |
5508 | |
5509 | if (!buffer.empty()) { |
5510 | unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift; |
5511 | if (lastScan < MaxNibble) { |
5512 | unsigned claimed = std::min(MaxNibble - lastScan, numWords); |
5513 | numWords -= claimed; |
5514 | lastScan += claimed; |
5515 | buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift); |
5516 | } |
5517 | } |
5518 | |
5519 | while (numWords >= MaxNibble) { |
5520 | buffer.push_back(MaxNibble << ScanShift); |
5521 | numWords -= MaxNibble; |
5522 | } |
5523 | if (numWords) { |
5524 | buffer.push_back(numWords << ScanShift); |
5525 | } |
5526 | }; |
5527 | |
5528 | |
5529 | unsigned endOfLastScanInWords = 0; |
5530 | const CharUnits WordSize = CGM.getPointerSize(); |
5531 | |
5532 | |
5533 | for (auto &request : IvarsInfo) { |
5534 | CharUnits beginOfScan = request.Offset - InstanceBegin; |
5535 | |
5536 | |
5537 | |
5538 | if ((beginOfScan % WordSize) != 0) continue; |
5539 | |
5540 | |
5541 | |
5542 | |
5543 | |
5544 | |
5545 | if (beginOfScan.isNegative()) { |
5546 | assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin); |
5547 | continue; |
5548 | } |
5549 | |
5550 | unsigned beginOfScanInWords = beginOfScan / WordSize; |
5551 | unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords; |
5552 | |
5553 | |
5554 | |
5555 | if (beginOfScanInWords > endOfLastScanInWords) { |
5556 | skip(beginOfScanInWords - endOfLastScanInWords); |
5557 | |
5558 | |
5559 | } else { |
5560 | beginOfScanInWords = endOfLastScanInWords; |
5561 | |
5562 | |
5563 | if (beginOfScanInWords >= endOfScanInWords) continue; |
5564 | } |
5565 | |
5566 | |
5567 | assert(beginOfScanInWords < endOfScanInWords); |
5568 | scan(endOfScanInWords - beginOfScanInWords); |
5569 | endOfLastScanInWords = endOfScanInWords; |
5570 | } |
5571 | |
5572 | if (buffer.empty()) |
5573 | return llvm::ConstantPointerNull::get(CGM.Int8PtrTy); |
5574 | |
5575 | |
5576 | |
5577 | |
5578 | if (CGM.getLangOpts().getGC() != LangOptions::NonGC) { |
5579 | unsigned lastOffsetInWords = |
5580 | (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize; |
5581 | if (lastOffsetInWords > endOfLastScanInWords) { |
5582 | skip(lastOffsetInWords - endOfLastScanInWords); |
5583 | } |
5584 | } |
5585 | |
5586 | |
5587 | buffer.push_back(0); |
5588 | |
5589 | auto *Entry = CGObjC.CreateCStringLiteral( |
5590 | reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName); |
5591 | return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0); |
5592 | } |
5593 | |
5594 | |
5595 | |
5596 | |
5597 | |
5598 | |
5599 | |
5600 | |
5601 | |
5602 | |
5603 | |
5604 | |
5605 | |
5606 | |
5607 | |
5608 | |
5609 | |
5610 | llvm::Constant * |
5611 | CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD, |
5612 | CharUnits beginOffset, CharUnits endOffset, |
5613 | bool ForStrongLayout, bool HasMRCWeakIvars) { |
5614 | |
5615 | |
5616 | llvm::Type *PtrTy = CGM.Int8PtrTy; |
5617 | if (CGM.getLangOpts().getGC() == LangOptions::NonGC && |
5618 | !CGM.getLangOpts().ObjCAutoRefCount && |
5619 | (ForStrongLayout || !HasMRCWeakIvars)) |
5620 | return llvm::Constant::getNullValue(PtrTy); |
5621 | |
5622 | const ObjCInterfaceDecl *OI = OMD->getClassInterface(); |
5623 | SmallVector<const ObjCIvarDecl*, 32> ivars; |
5624 | |
5625 | |
5626 | |
5627 | |
5628 | |
5629 | |
5630 | |
5631 | |
5632 | |
5633 | |
5634 | |
5635 | CharUnits baseOffset; |
5636 | if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { |
5637 | for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin(); |
5638 | IVD; IVD = IVD->getNextIvar()) |
5639 | ivars.push_back(IVD); |
5640 | |
5641 | if (isNonFragileABI()) { |
5642 | baseOffset = beginOffset; |
5643 | } else if (!ivars.empty()) { |
5644 | baseOffset = |
5645 | CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0])); |
5646 | } else { |
5647 | baseOffset = CharUnits::Zero(); |
5648 | } |
5649 | |
5650 | baseOffset = baseOffset.alignTo(CGM.getPointerAlign()); |
5651 | } |
5652 | else { |
5653 | CGM.getContext().DeepCollectObjCIvars(OI, true, ivars); |
5654 | |
5655 | baseOffset = CharUnits::Zero(); |
5656 | } |
5657 | |
5658 | if (ivars.empty()) |
5659 | return llvm::Constant::getNullValue(PtrTy); |
5660 | |
5661 | IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout); |
5662 | |
5663 | builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(), |
5664 | [&](const ObjCIvarDecl *ivar) -> CharUnits { |
5665 | return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar)); |
5666 | }); |
5667 | |
5668 | if (!builder.hasBitmapData()) |
5669 | return llvm::Constant::getNullValue(PtrTy); |
5670 | |
5671 | llvm::SmallVector<unsigned char, 4> buffer; |
5672 | llvm::Constant *C = builder.buildBitmap(*this, buffer); |
5673 | |
5674 | if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) { |
5675 | printf("\n%s ivar layout for class '%s': ", |
5676 | ForStrongLayout ? "strong" : "weak", |
5677 | OMD->getClassInterface()->getName().str().c_str()); |
5678 | builder.dump(buffer); |
5679 | } |
5680 | return C; |
5681 | } |
5682 | |
5683 | llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) { |
5684 | llvm::GlobalVariable *&Entry = MethodVarNames[Sel]; |
5685 | |
5686 | if (!Entry) |
5687 | Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName); |
5688 | return getConstantGEP(VMContext, Entry, 0, 0); |
5689 | } |
5690 | |
5691 | |
5692 | llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) { |
5693 | return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID)); |
5694 | } |
5695 | |
5696 | llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) { |
5697 | std::string TypeStr; |
5698 | CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field); |
5699 | |
5700 | llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; |
5701 | if (!Entry) |
5702 | Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType); |
5703 | return getConstantGEP(VMContext, Entry, 0, 0); |
5704 | } |
5705 | |
5706 | llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D, |
5707 | bool Extended) { |
5708 | std::string TypeStr = |
5709 | CGM.getContext().getObjCEncodingForMethodDecl(D, Extended); |
5710 | |
5711 | llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; |
5712 | if (!Entry) |
5713 | Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType); |
5714 | return getConstantGEP(VMContext, Entry, 0, 0); |
5715 | } |
5716 | |
5717 | |
5718 | llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) { |
5719 | llvm::GlobalVariable *&Entry = PropertyNames[Ident]; |
5720 | if (!Entry) |
5721 | Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName); |
5722 | return getConstantGEP(VMContext, Entry, 0, 0); |
5723 | } |
5724 | |
5725 | |
5726 | |
5727 | llvm::Constant * |
5728 | CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD, |
5729 | const Decl *Container) { |
5730 | std::string TypeStr = |
5731 | CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container); |
5732 | return GetPropertyName(&CGM.getContext().Idents.get(TypeStr)); |
5733 | } |
5734 | |
5735 | void CGObjCMac::FinishModule() { |
5736 | EmitModuleInfo(); |
5737 | |
5738 | |
5739 | |
5740 | for (auto &entry : Protocols) { |
5741 | llvm::GlobalVariable *global = entry.second; |
5742 | if (global->hasInitializer()) |
5743 | continue; |
5744 | |
5745 | ConstantInitBuilder builder(CGM); |
5746 | auto values = builder.beginStruct(ObjCTypes.ProtocolTy); |
5747 | values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy); |
5748 | values.add(GetClassName(entry.first->getName())); |
5749 | values.addNullPointer(ObjCTypes.ProtocolListPtrTy); |
5750 | values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy); |
5751 | values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy); |
5752 | values.finishAndSetAsInitializer(global); |
5753 | CGM.addCompilerUsedGlobal(global); |
5754 | } |
5755 | |
5756 | |
5757 | |
5758 | |
5759 | |
5760 | |
5761 | if ((!LazySymbols.empty() || !DefinedSymbols.empty()) && |
5762 | CGM.getTriple().isOSBinFormatMachO()) { |
5763 | SmallString<256> Asm; |
5764 | Asm += CGM.getModule().getModuleInlineAsm(); |
5765 | if (!Asm.empty() && Asm.back() != '\n') |
5766 | Asm += '\n'; |
5767 | |
5768 | llvm::raw_svector_ostream OS(Asm); |
5769 | for (const auto *Sym : DefinedSymbols) |
5770 | OS << "\t.objc_class_name_" << Sym->getName() << "=0\n" |
5771 | << "\t.globl .objc_class_name_" << Sym->getName() << "\n"; |
5772 | for (const auto *Sym : LazySymbols) |
5773 | OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n"; |
5774 | for (const auto &Category : DefinedCategoryNames) |
5775 | OS << "\t.objc_category_name_" << Category << "=0\n" |
5776 | << "\t.globl .objc_category_name_" << Category << "\n"; |
5777 | |
5778 | CGM.getModule().setModuleInlineAsm(OS.str()); |
5779 | } |
5780 | } |
5781 | |
5782 | CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm) |
5783 | : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr), |
5784 | ObjCEmptyVtableVar(nullptr) { |
5785 | ObjCABI = 2; |
5786 | } |
5787 | |
5788 | |
5789 | |
5790 | ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm) |
5791 | : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr) |
5792 | { |
5793 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
5794 | ASTContext &Ctx = CGM.getContext(); |
5795 | |
5796 | ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy)); |
5797 | IntTy = CGM.IntTy; |
5798 | LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy)); |
5799 | Int8PtrTy = CGM.Int8PtrTy; |
5800 | Int8PtrPtrTy = CGM.Int8PtrPtrTy; |
5801 | |
5802 | |
5803 | |
5804 | if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64) |
5805 | IvarOffsetVarTy = IntTy; |
5806 | else |
5807 | IvarOffsetVarTy = LongTy; |
5808 | |
5809 | ObjectPtrTy = |
5810 | cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType())); |
5811 | PtrObjectPtrTy = |
5812 | llvm::PointerType::getUnqual(ObjectPtrTy); |
5813 | SelectorPtrTy = |
5814 | cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType())); |
5815 | |
5816 | |
5817 | |
5818 | |
5819 | |
5820 | |
5821 | |
5822 | |
5823 | |
5824 | |
5825 | |
5826 | |
5827 | |
5828 | RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct, |
5829 | Ctx.getTranslationUnitDecl(), |
5830 | SourceLocation(), SourceLocation(), |
5831 | &Ctx.Idents.get("_objc_super")); |
5832 | RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), |
5833 | nullptr, Ctx.getObjCIdType(), nullptr, nullptr, |
5834 | false, ICIS_NoInit)); |
5835 | RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), |
5836 | nullptr, Ctx.getObjCClassType(), nullptr, |
5837 | nullptr, false, ICIS_NoInit)); |
5838 | RD->completeDefinition(); |
5839 | |
5840 | SuperCTy = Ctx.getTagDeclType(RD); |
5841 | SuperPtrCTy = Ctx.getPointerType(SuperCTy); |
5842 | |
5843 | SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy)); |
5844 | SuperPtrTy = llvm::PointerType::getUnqual(SuperTy); |
5845 | |
5846 | |
5847 | |
5848 | |
5849 | |
5850 | PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy); |
5851 | |
5852 | |
5853 | |
5854 | |
5855 | |
5856 | |
5857 | PropertyListTy = llvm::StructType::create( |
5858 | "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0)); |
5859 | |
5860 | PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy); |
5861 | |
5862 | |
5863 | |
5864 | |
5865 | |
5866 | |
5867 | MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy, |
5868 | Int8PtrTy, Int8PtrTy); |
5869 | |
5870 | |
5871 | CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache"); |
5872 | CachePtrTy = llvm::PointerType::getUnqual(CacheTy); |
5873 | } |
5874 | |
5875 | ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm) |
5876 | : ObjCCommonTypesHelper(cgm) { |
5877 | |
5878 | |
5879 | |
5880 | |
5881 | MethodDescriptionTy = llvm::StructType::create( |
5882 | "struct._objc_method_description", SelectorPtrTy, Int8PtrTy); |
5883 | |
5884 | |
5885 | |
5886 | |
5887 | |
5888 | MethodDescriptionListTy = |
5889 | llvm::StructType::create("struct._objc_method_description_list", IntTy, |
5890 | llvm::ArrayType::get(MethodDescriptionTy, 0)); |
5891 | |
5892 | |
5893 | MethodDescriptionListPtrTy = |
5894 | llvm::PointerType::getUnqual(MethodDescriptionListTy); |
5895 | |
5896 | |
5897 | |
5898 | |
5899 | |
5900 | |
5901 | |
5902 | |
5903 | |
5904 | |
5905 | |
5906 | ProtocolExtensionTy = llvm::StructType::create( |
5907 | "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy, |
5908 | MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy, |
5909 | PropertyListPtrTy); |
5910 | |
5911 | |
5912 | ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy); |
5913 | |
5914 | |
5915 | |
5916 | ProtocolTy = |
5917 | llvm::StructType::create(VMContext, "struct._objc_protocol"); |
5918 | |
5919 | ProtocolListTy = |
5920 | llvm::StructType::create(VMContext, "struct._objc_protocol_list"); |
5921 | ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy, |
5922 | llvm::ArrayType::get(ProtocolTy, 0)); |
5923 | |
5924 | |
5925 | |
5926 | |
5927 | |
5928 | |
5929 | |
5930 | |
5931 | ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy, |
5932 | llvm::PointerType::getUnqual(ProtocolListTy), |
5933 | MethodDescriptionListPtrTy, MethodDescriptionListPtrTy); |
5934 | |
5935 | |
5936 | ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy); |
5937 | |
5938 | ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy); |
5939 | |
5940 | |
5941 | |
5942 | |
5943 | |
5944 | |
5945 | |
5946 | |
5947 | IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy, |
5948 | IntTy); |
5949 | |
5950 | |
5951 | IvarListTy = |
5952 | llvm::StructType::create(VMContext, "struct._objc_ivar_list"); |
5953 | IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy); |
5954 | |
5955 | |
5956 | MethodListTy = |
5957 | llvm::StructType::create(VMContext, "struct._objc_method_list"); |
5958 | MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy); |
5959 | |
5960 | |
5961 | ClassExtensionTy = llvm::StructType::create( |
5962 | "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy); |
5963 | ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy); |
5964 | |
5965 | ClassTy = llvm::StructType::create(VMContext, "struct._objc_class"); |
5966 | |
5967 | |
5968 | |
5969 | |
5970 | |
5971 | |
5972 | |
5973 | |
5974 | |
5975 | |
5976 | |
5977 | |
5978 | |
5979 | |
5980 | |
5981 | ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy), |
5982 | llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy, |
5983 | LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy, |
5984 | ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy); |
5985 | |
5986 | ClassPtrTy = llvm::PointerType::getUnqual(ClassTy); |
5987 | |
5988 | |
5989 | |
5990 | |
5991 | |
5992 | |
5993 | |
5994 | |
5995 | |
5996 | |
5997 | |
5998 | CategoryTy = llvm::StructType::create( |
5999 | "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy, |
6000 | MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy, |
6001 | PropertyListPtrTy); |
6002 | |
6003 | |
6004 | |
6005 | |
6006 | |
6007 | |
6008 | |
6009 | |
6010 | |
6011 | |
6012 | SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy, |
6013 | SelectorPtrTy, ShortTy, ShortTy, |
6014 | llvm::ArrayType::get(Int8PtrTy, 0)); |
6015 | SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy); |
6016 | |
6017 | |
6018 | |
6019 | |
6020 | |
6021 | |
6022 | |
6023 | ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy, |
6024 | Int8PtrTy, SymtabPtrTy); |
6025 | |
6026 | |
6027 | |
6028 | uint64_t SetJmpBufferSize = 18; |
6029 | |
6030 | |
6031 | llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4); |
6032 | |
6033 | ExceptionDataTy = llvm::StructType::create( |
6034 | "struct._objc_exception_data", |
6035 | llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy); |
6036 | } |
6037 | |
6038 | ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm) |
6039 | : ObjCCommonTypesHelper(cgm) { |
6040 | |
6041 | |
6042 | |
6043 | |
6044 | |
6045 | MethodListnfABITy = |
6046 | llvm::StructType::create("struct.__method_list_t", IntTy, IntTy, |
6047 | llvm::ArrayType::get(MethodTy, 0)); |
6048 | |
6049 | MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy); |
6050 | |
6051 | |
6052 | |
6053 | |
6054 | |
6055 | |
6056 | |
6057 | |
6058 | |
6059 | |
6060 | |
6061 | |
6062 | |
6063 | |
6064 | |
6065 | |
6066 | |
6067 | |
6068 | ProtocolListnfABITy = |
6069 | llvm::StructType::create(VMContext, "struct._objc_protocol_list"); |
6070 | |
6071 | ProtocolnfABITy = llvm::StructType::create( |
6072 | "struct._protocol_t", ObjectPtrTy, Int8PtrTy, |
6073 | llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy, |
6074 | MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy, |
6075 | PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy, |
6076 | PropertyListPtrTy); |
6077 | |
6078 | |
6079 | ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy); |
6080 | |
6081 | |
6082 | |
6083 | |
6084 | |
6085 | ProtocolListnfABITy->setBody(LongTy, |
6086 | llvm::ArrayType::get(ProtocolnfABIPtrTy, 0)); |
6087 | |
6088 | |
6089 | ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy); |
6090 | |
6091 | |
6092 | |
6093 | |
6094 | |
6095 | |
6096 | |
6097 | |
6098 | IvarnfABITy = llvm::StructType::create( |
6099 | "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy), |
6100 | Int8PtrTy, Int8PtrTy, IntTy, IntTy); |
6101 | |
6102 | |
6103 | |
6104 | |
6105 | |
6106 | |
6107 | IvarListnfABITy = |
6108 | llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy, |
6109 | llvm::ArrayType::get(IvarnfABITy, 0)); |
6110 | |
6111 | IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy); |
6112 | |
6113 | |
6114 | |
6115 | |
6116 | |
6117 | |
6118 | |
6119 | |
6120 | |
6121 | |
6122 | |
6123 | |
6124 | |
6125 | |
6126 | |
6127 | |
6128 | ClassRonfABITy = llvm::StructType::create( |
6129 | "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy, |
6130 | MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy, |
6131 | Int8PtrTy, PropertyListPtrTy); |
6132 | |
6133 | |
6134 | llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
6135 | ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false) |
6136 | ->getPointerTo(); |
6137 | |
6138 | |
6139 | |
6140 | |
6141 | |
6142 | |
6143 | |
6144 | |
6145 | |
6146 | ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t"); |
6147 | ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy), |
6148 | llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy, |
6149 | llvm::PointerType::getUnqual(ImpnfABITy), |
6150 | llvm::PointerType::getUnqual(ClassRonfABITy)); |
6151 | |
6152 | |
6153 | ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy); |
6154 | |
6155 | |
6156 | |
6157 | |
6158 | |
6159 | |
6160 | |
6161 | |
6162 | |
6163 | |
6164 | |
6165 | CategorynfABITy = llvm::StructType::create( |
6166 | "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy, |
6167 | MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy, |
6168 | PropertyListPtrTy, IntTy); |
6169 | |
6170 | |
6171 | CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
6172 | ASTContext &Ctx = CGM.getContext(); |
6173 | |
6174 | |
6175 | |
6176 | |
6177 | |
6178 | |
6179 | |
6180 | |
6181 | RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct, |
6182 | Ctx.getTranslationUnitDecl(), |
6183 | SourceLocation(), SourceLocation(), |
6184 | &Ctx.Idents.get("_message_ref_t")); |
6185 | RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), |
6186 | nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false, |
6187 | ICIS_NoInit)); |
6188 | RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), |
6189 | nullptr, Ctx.getObjCSelType(), nullptr, nullptr, |
6190 | false, ICIS_NoInit)); |
6191 | RD->completeDefinition(); |
6192 | |
6193 | MessageRefCTy = Ctx.getTagDeclType(RD); |
6194 | MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy); |
6195 | MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy)); |
6196 | |
6197 | |
6198 | MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy); |
6199 | |
6200 | |
6201 | |
6202 | |
6203 | |
6204 | |
|