clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGObjCGNU.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/CGObjCGNU.cpp
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | |
15 | |
16 | #include "CGCXXABI.h" |
17 | #include "CGCleanup.h" |
18 | #include "CGObjCRuntime.h" |
19 | #include "CodeGenFunction.h" |
20 | #include "CodeGenModule.h" |
21 | #include "clang/AST/ASTContext.h" |
22 | #include "clang/AST/Attr.h" |
23 | #include "clang/AST/Decl.h" |
24 | #include "clang/AST/DeclObjC.h" |
25 | #include "clang/AST/RecordLayout.h" |
26 | #include "clang/AST/StmtObjC.h" |
27 | #include "clang/Basic/FileManager.h" |
28 | #include "clang/Basic/SourceManager.h" |
29 | #include "clang/CodeGen/ConstantInitBuilder.h" |
30 | #include "llvm/ADT/SmallVector.h" |
31 | #include "llvm/ADT/StringMap.h" |
32 | #include "llvm/IR/DataLayout.h" |
33 | #include "llvm/IR/Intrinsics.h" |
34 | #include "llvm/IR/LLVMContext.h" |
35 | #include "llvm/IR/Module.h" |
36 | #include "llvm/Support/Compiler.h" |
37 | #include "llvm/Support/ConvertUTF.h" |
38 | #include <cctype> |
39 | |
40 | using namespace clang; |
41 | using namespace CodeGen; |
42 | |
43 | namespace { |
44 | |
45 | |
46 | |
47 | |
48 | class LazyRuntimeFunction { |
49 | CodeGenModule *CGM; |
50 | llvm::FunctionType *FTy; |
51 | const char *FunctionName; |
52 | llvm::FunctionCallee Function; |
53 | |
54 | public: |
55 | |
56 | |
57 | |
58 | LazyRuntimeFunction() |
59 | : CGM(nullptr), FunctionName(nullptr), Function(nullptr) {} |
60 | |
61 | |
62 | |
63 | template <typename... Tys> |
64 | void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy, |
65 | Tys *... Types) { |
66 | CGM = Mod; |
67 | FunctionName = name; |
68 | Function = nullptr; |
69 | if(sizeof...(Tys)) { |
70 | SmallVector<llvm::Type *, 8> ArgTys({Types...}); |
71 | FTy = llvm::FunctionType::get(RetTy, ArgTys, false); |
72 | } |
73 | else { |
74 | FTy = llvm::FunctionType::get(RetTy, None, false); |
75 | } |
76 | } |
77 | |
78 | llvm::FunctionType *getType() { return FTy; } |
79 | |
80 | |
81 | |
82 | operator llvm::FunctionCallee() { |
83 | if (!Function) { |
84 | if (!FunctionName) |
85 | return nullptr; |
86 | Function = CGM->CreateRuntimeFunction(FTy, FunctionName); |
87 | } |
88 | return Function; |
89 | } |
90 | }; |
91 | |
92 | |
93 | |
94 | |
95 | |
96 | class CGObjCGNU : public CGObjCRuntime { |
97 | protected: |
98 | |
99 | llvm::Module &TheModule; |
100 | |
101 | |
102 | llvm::StructType *ObjCSuperTy; |
103 | |
104 | |
105 | llvm::PointerType *PtrToObjCSuperTy; |
106 | |
107 | |
108 | |
109 | llvm::PointerType *SelectorTy; |
110 | |
111 | |
112 | llvm::IntegerType *Int8Ty; |
113 | |
114 | |
115 | llvm::PointerType *PtrToInt8Ty; |
116 | |
117 | llvm::StructType *ProtocolTy; |
118 | |
119 | llvm::PointerType *ProtocolPtrTy; |
120 | |
121 | |
122 | |
123 | |
124 | |
125 | llvm::PointerType *IMPTy; |
126 | |
127 | |
128 | |
129 | |
130 | llvm::PointerType *IdTy; |
131 | |
132 | |
133 | llvm::PointerType *PtrToIdTy; |
134 | |
135 | |
136 | CanQualType ASTIdTy; |
137 | |
138 | llvm::IntegerType *IntTy; |
139 | |
140 | |
141 | |
142 | llvm::PointerType *PtrTy; |
143 | |
144 | |
145 | |
146 | llvm::IntegerType *LongTy; |
147 | |
148 | llvm::IntegerType *SizeTy; |
149 | |
150 | llvm::IntegerType *IntPtrTy; |
151 | |
152 | llvm::IntegerType *PtrDiffTy; |
153 | |
154 | |
155 | llvm::PointerType *PtrToIntTy; |
156 | |
157 | llvm::Type *BoolTy; |
158 | |
159 | llvm::IntegerType *Int32Ty; |
160 | |
161 | llvm::IntegerType *Int64Ty; |
162 | |
163 | llvm::StructType *PropertyMetadataTy; |
164 | |
165 | |
166 | |
167 | unsigned msgSendMDKind; |
168 | |
169 | |
170 | bool usesSEHExceptions; |
171 | |
172 | |
173 | bool isRuntime(ObjCRuntime::Kind kind, unsigned major, unsigned minor=0) { |
174 | const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime; |
175 | return (R.getKind() == kind) && |
176 | (R.getVersion() >= VersionTuple(major, minor)); |
177 | } |
178 | |
179 | std::string ManglePublicSymbol(StringRef Name) { |
180 | return (StringRef(CGM.getTriple().isOSBinFormatCOFF() ? "$_" : "._") + Name).str(); |
181 | } |
182 | |
183 | std::string SymbolForProtocol(Twine Name) { |
184 | return (ManglePublicSymbol("OBJC_PROTOCOL_") + Name).str(); |
185 | } |
186 | |
187 | std::string SymbolForProtocolRef(StringRef Name) { |
188 | return (ManglePublicSymbol("OBJC_REF_PROTOCOL_") + Name).str(); |
189 | } |
190 | |
191 | |
192 | |
193 | |
194 | |
195 | llvm::Constant *MakeConstantString(StringRef Str, const char *Name = "") { |
196 | ConstantAddress Array = |
197 | CGM.GetAddrOfConstantCString(std::string(Str), Name); |
198 | return llvm::ConstantExpr::getGetElementPtr(Array.getElementType(), |
199 | Array.getPointer(), Zeros); |
200 | } |
201 | |
202 | |
203 | |
204 | |
205 | |
206 | llvm::Constant *ExportUniqueString(const std::string &Str, |
207 | const std::string &prefix, |
208 | bool Private=false) { |
209 | std::string name = prefix + Str; |
210 | auto *ConstStr = TheModule.getGlobalVariable(name); |
211 | if (!ConstStr) { |
212 | llvm::Constant *value = llvm::ConstantDataArray::getString(VMContext,Str); |
213 | auto *GV = new llvm::GlobalVariable(TheModule, value->getType(), true, |
214 | llvm::GlobalValue::LinkOnceODRLinkage, value, name); |
215 | GV->setComdat(TheModule.getOrInsertComdat(name)); |
216 | if (Private) |
217 | GV->setVisibility(llvm::GlobalValue::HiddenVisibility); |
218 | ConstStr = GV; |
219 | } |
220 | return llvm::ConstantExpr::getGetElementPtr(ConstStr->getValueType(), |
221 | ConstStr, Zeros); |
222 | } |
223 | |
224 | |
225 | llvm::Constant *MakePropertyEncodingString(const ObjCPropertyDecl *PD, |
226 | const Decl *Container) { |
227 | assert(!isRuntime(ObjCRuntime::GNUstep, 2)); |
228 | if (isRuntime(ObjCRuntime::GNUstep, 1, 6)) { |
229 | std::string NameAndAttributes; |
230 | std::string TypeStr = |
231 | CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container); |
232 | NameAndAttributes += '\0'; |
233 | NameAndAttributes += TypeStr.length() + 3; |
234 | NameAndAttributes += TypeStr; |
235 | NameAndAttributes += '\0'; |
236 | NameAndAttributes += PD->getNameAsString(); |
237 | return MakeConstantString(NameAndAttributes); |
238 | } |
239 | return MakeConstantString(PD->getNameAsString()); |
240 | } |
241 | |
242 | |
243 | void PushPropertyAttributes(ConstantStructBuilder &Fields, |
244 | const ObjCPropertyDecl *property, bool isSynthesized=true, bool |
245 | isDynamic=true) { |
246 | int attrs = property->getPropertyAttributes(); |
247 | |
248 | if (attrs & ObjCPropertyAttribute::kind_readonly) { |
249 | attrs &= ~ObjCPropertyAttribute::kind_copy; |
250 | attrs &= ~ObjCPropertyAttribute::kind_retain; |
251 | attrs &= ~ObjCPropertyAttribute::kind_weak; |
252 | attrs &= ~ObjCPropertyAttribute::kind_strong; |
253 | } |
254 | |
255 | Fields.addInt(Int8Ty, attrs & 0xff); |
256 | attrs >>= 8; |
257 | attrs <<= 2; |
258 | |
259 | |
260 | |
261 | attrs |= isSynthesized ? (1<<0) : 0; |
262 | attrs |= isDynamic ? (1<<1) : 0; |
263 | |
264 | |
265 | Fields.addInt(Int8Ty, attrs & 0xff); |
266 | |
267 | Fields.addInt(Int8Ty, 0); |
268 | Fields.addInt(Int8Ty, 0); |
269 | } |
270 | |
271 | virtual llvm::Constant *GenerateCategoryProtocolList(const |
272 | ObjCCategoryDecl *OCD); |
273 | virtual ConstantArrayBuilder PushPropertyListHeader(ConstantStructBuilder &Fields, |
274 | int count) { |
275 | |
276 | Fields.addInt(IntTy, count); |
277 | |
278 | if (isRuntime(ObjCRuntime::GNUstep, 2)) { |
279 | llvm::DataLayout td(&TheModule); |
280 | Fields.addInt(IntTy, td.getTypeSizeInBits(PropertyMetadataTy) / |
281 | CGM.getContext().getCharWidth()); |
282 | } |
283 | |
284 | Fields.add(NULLPtr); |
285 | |
286 | return Fields.beginArray(PropertyMetadataTy); |
287 | } |
288 | virtual void PushProperty(ConstantArrayBuilder &PropertiesArray, |
289 | const ObjCPropertyDecl *property, |
290 | const Decl *OCD, |
291 | bool isSynthesized=true, bool |
292 | isDynamic=true) { |
293 | auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy); |
294 | ASTContext &Context = CGM.getContext(); |
295 | Fields.add(MakePropertyEncodingString(property, OCD)); |
296 | PushPropertyAttributes(Fields, property, isSynthesized, isDynamic); |
297 | auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) { |
298 | if (accessor) { |
299 | std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor); |
300 | llvm::Constant *TypeEncoding = MakeConstantString(TypeStr); |
301 | Fields.add(MakeConstantString(accessor->getSelector().getAsString())); |
302 | Fields.add(TypeEncoding); |
303 | } else { |
304 | Fields.add(NULLPtr); |
305 | Fields.add(NULLPtr); |
306 | } |
307 | }; |
308 | addPropertyMethod(property->getGetterMethodDecl()); |
309 | addPropertyMethod(property->getSetterMethodDecl()); |
310 | Fields.finishAndAddTo(PropertiesArray); |
311 | } |
312 | |
313 | |
314 | |
315 | |
316 | llvm::Value* EnforceType(CGBuilderTy &B, llvm::Value *V, llvm::Type *Ty) { |
317 | if (V->getType() == Ty) return V; |
318 | return B.CreateBitCast(V, Ty); |
319 | } |
320 | Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) { |
321 | if (V.getType() == Ty) return V; |
322 | return B.CreateBitCast(V, Ty); |
323 | } |
324 | |
325 | |
326 | llvm::Constant *Zeros[2]; |
327 | |
328 | llvm::Constant *NULLPtr; |
329 | |
330 | llvm::LLVMContext &VMContext; |
331 | |
332 | protected: |
333 | |
334 | |
335 | |
336 | |
337 | |
338 | llvm::GlobalAlias *ClassPtrAlias; |
339 | |
340 | |
341 | |
342 | |
343 | llvm::GlobalAlias *MetaClassPtrAlias; |
344 | |
345 | std::vector<llvm::Constant*> Classes; |
346 | |
347 | std::vector<llvm::Constant*> Categories; |
348 | |
349 | |
350 | std::vector<llvm::Constant*> ConstantStrings; |
351 | |
352 | |
353 | |
354 | llvm::StringMap<llvm::Constant*> ObjCStrings; |
355 | |
356 | llvm::StringMap<llvm::Constant*> ExistingProtocols; |
357 | |
358 | |
359 | |
360 | |
361 | |
362 | typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector; |
363 | |
364 | |
365 | |
366 | typedef llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> > |
367 | SelectorMap; |
368 | |
369 | |
370 | SelectorMap SelectorTable; |
371 | |
372 | |
373 | |
374 | Selector RetainSel, ReleaseSel, AutoreleaseSel; |
375 | |
376 | |
377 | |
378 | LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn, |
379 | WeakAssignFn, GlobalAssignFn; |
380 | |
381 | typedef std::pair<std::string, std::string> ClassAliasPair; |
382 | |
383 | std::vector<ClassAliasPair> ClassAliases; |
384 | |
385 | protected: |
386 | |
387 | LazyRuntimeFunction ExceptionThrowFn; |
388 | |
389 | |
390 | LazyRuntimeFunction ExceptionReThrowFn; |
391 | |
392 | |
393 | LazyRuntimeFunction EnterCatchFn; |
394 | |
395 | |
396 | LazyRuntimeFunction ExitCatchFn; |
397 | |
398 | LazyRuntimeFunction SyncEnterFn; |
399 | |
400 | LazyRuntimeFunction SyncExitFn; |
401 | |
402 | private: |
403 | |
404 | |
405 | LazyRuntimeFunction EnumerationMutationFn; |
406 | |
407 | |
408 | LazyRuntimeFunction GetPropertyFn; |
409 | |
410 | |
411 | LazyRuntimeFunction SetPropertyFn; |
412 | |
413 | LazyRuntimeFunction GetStructPropertyFn; |
414 | |
415 | LazyRuntimeFunction SetStructPropertyFn; |
416 | |
417 | protected: |
418 | |
419 | |
420 | int RuntimeVersion; |
421 | |
422 | |
423 | |
424 | |
425 | |
426 | |
427 | const int ProtocolVersion; |
428 | |
429 | |
430 | const int ClassABIVersion; |
431 | |
432 | |
433 | |
434 | |
435 | virtual llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames, |
436 | ArrayRef<llvm::Constant *> IvarTypes, |
437 | ArrayRef<llvm::Constant *> IvarOffsets, |
438 | ArrayRef<llvm::Constant *> IvarAlign, |
439 | ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership); |
440 | |
441 | |
442 | |
443 | |
444 | |
445 | |
446 | llvm::Constant *GenerateMethodList(StringRef ClassName, |
447 | StringRef CategoryName, |
448 | ArrayRef<const ObjCMethodDecl*> Methods, |
449 | bool isClassMethodList); |
450 | |
451 | |
452 | |
453 | |
454 | virtual llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName); |
455 | |
456 | |
457 | |
458 | llvm::Constant *GeneratePropertyList(const Decl *Container, |
459 | const ObjCContainerDecl *OCD, |
460 | bool isClassProperty=false, |
461 | bool protocolOptionalProperties=false); |
462 | |
463 | |
464 | |
465 | llvm::Constant *GenerateProtocolList(ArrayRef<std::string> Protocols); |
466 | |
467 | |
468 | |
469 | |
470 | |
471 | void GenerateProtocolHolderCategory(); |
472 | |
473 | |
474 | llvm::Constant *GenerateClassStructure( |
475 | llvm::Constant *MetaClass, |
476 | llvm::Constant *SuperClass, |
477 | unsigned info, |
478 | const char *Name, |
479 | llvm::Constant *Version, |
480 | llvm::Constant *InstanceSize, |
481 | llvm::Constant *IVars, |
482 | llvm::Constant *Methods, |
483 | llvm::Constant *Protocols, |
484 | llvm::Constant *IvarOffsets, |
485 | llvm::Constant *Properties, |
486 | llvm::Constant *StrongIvarBitmap, |
487 | llvm::Constant *WeakIvarBitmap, |
488 | bool isMeta=false); |
489 | |
490 | |
491 | |
492 | virtual llvm::Constant *GenerateProtocolMethodList( |
493 | ArrayRef<const ObjCMethodDecl*> Methods); |
494 | |
495 | template<class T> |
496 | void EmitProtocolMethodList(T &&Methods, llvm::Constant *&Required, |
497 | llvm::Constant *&Optional) { |
498 | SmallVector<const ObjCMethodDecl*, 16> RequiredMethods; |
499 | SmallVector<const ObjCMethodDecl*, 16> OptionalMethods; |
500 | for (const auto *I : Methods) |
501 | if (I->isOptional()) |
502 | OptionalMethods.push_back(I); |
503 | else |
504 | RequiredMethods.push_back(I); |
505 | Required = GenerateProtocolMethodList(RequiredMethods); |
506 | Optional = GenerateProtocolMethodList(OptionalMethods); |
507 | } |
508 | |
509 | |
510 | |
511 | virtual llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel, |
512 | const std::string &TypeEncoding); |
513 | |
514 | |
515 | |
516 | |
517 | virtual std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID, |
518 | const ObjCIvarDecl *Ivar) { |
519 | const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString() |
520 | + '.' + Ivar->getNameAsString(); |
521 | return Name; |
522 | } |
523 | |
524 | llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID, |
525 | const ObjCIvarDecl *Ivar); |
526 | |
527 | |
528 | void EmitClassRef(const std::string &className); |
529 | |
530 | |
531 | virtual llvm::Value *GetClassNamed(CodeGenFunction &CGF, |
532 | const std::string &Name, bool isWeak); |
533 | |
534 | |
535 | |
536 | |
537 | virtual llvm::Value *LookupIMP(CodeGenFunction &CGF, |
538 | llvm::Value *&Receiver, |
539 | llvm::Value *cmd, |
540 | llvm::MDNode *node, |
541 | MessageSendInfo &MSI) = 0; |
542 | |
543 | |
544 | |
545 | |
546 | virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, |
547 | Address ObjCSuper, |
548 | llvm::Value *cmd, |
549 | MessageSendInfo &MSI) = 0; |
550 | |
551 | |
552 | |
553 | |
554 | |
555 | |
556 | |
557 | |
558 | |
559 | |
560 | |
561 | |
562 | llvm::Constant *MakeBitField(ArrayRef<bool> bits); |
563 | |
564 | public: |
565 | CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion, |
566 | unsigned protocolClassVersion, unsigned classABI=1); |
567 | |
568 | ConstantAddress GenerateConstantString(const StringLiteral *) override; |
569 | |
570 | RValue |
571 | GenerateMessageSend(CodeGenFunction &CGF, ReturnValueSlot Return, |
572 | QualType ResultType, Selector Sel, |
573 | llvm::Value *Receiver, const CallArgList &CallArgs, |
574 | const ObjCInterfaceDecl *Class, |
575 | const ObjCMethodDecl *Method) override; |
576 | RValue |
577 | GenerateMessageSendSuper(CodeGenFunction &CGF, ReturnValueSlot Return, |
578 | QualType ResultType, Selector Sel, |
579 | const ObjCInterfaceDecl *Class, |
580 | bool isCategoryImpl, llvm::Value *Receiver, |
581 | bool IsClassMessage, const CallArgList &CallArgs, |
582 | const ObjCMethodDecl *Method) override; |
583 | llvm::Value *GetClass(CodeGenFunction &CGF, |
584 | const ObjCInterfaceDecl *OID) override; |
585 | llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override; |
586 | Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override; |
587 | llvm::Value *GetSelector(CodeGenFunction &CGF, |
588 | const ObjCMethodDecl *Method) override; |
589 | virtual llvm::Constant *GetConstantSelector(Selector Sel, |
590 | const std::string &TypeEncoding) { |
591 | llvm_unreachable("Runtime unable to generate constant selector"); |
592 | } |
593 | llvm::Constant *GetConstantSelector(const ObjCMethodDecl *M) { |
594 | return GetConstantSelector(M->getSelector(), |
595 | CGM.getContext().getObjCEncodingForMethodDecl(M)); |
596 | } |
597 | llvm::Constant *GetEHType(QualType T) override; |
598 | |
599 | llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, |
600 | const ObjCContainerDecl *CD) override; |
601 | void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn, |
602 | const ObjCMethodDecl *OMD, |
603 | const ObjCContainerDecl *CD) override; |
604 | void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; |
605 | void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; |
606 | void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override; |
607 | llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, |
608 | const ObjCProtocolDecl *PD) override; |
609 | void GenerateProtocol(const ObjCProtocolDecl *PD) override; |
610 | |
611 | virtual llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD); |
612 | |
613 | llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override { |
614 | return GenerateProtocolRef(PD); |
615 | } |
616 | |
617 | llvm::Function *ModuleInitFunction() override; |
618 | llvm::FunctionCallee GetPropertyGetFunction() override; |
619 | llvm::FunctionCallee GetPropertySetFunction() override; |
620 | llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, |
621 | bool copy) override; |
622 | llvm::FunctionCallee GetSetStructFunction() override; |
623 | llvm::FunctionCallee GetGetStructFunction() override; |
624 | llvm::FunctionCallee GetCppAtomicObjectGetFunction() override; |
625 | llvm::FunctionCallee GetCppAtomicObjectSetFunction() override; |
626 | llvm::FunctionCallee EnumerationMutationFunction() override; |
627 | |
628 | void EmitTryStmt(CodeGenFunction &CGF, |
629 | const ObjCAtTryStmt &S) override; |
630 | void EmitSynchronizedStmt(CodeGenFunction &CGF, |
631 | const ObjCAtSynchronizedStmt &S) override; |
632 | void EmitThrowStmt(CodeGenFunction &CGF, |
633 | const ObjCAtThrowStmt &S, |
634 | bool ClearInsertionPoint=true) override; |
635 | llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF, |
636 | Address AddrWeakObj) override; |
637 | void EmitObjCWeakAssign(CodeGenFunction &CGF, |
638 | llvm::Value *src, Address dst) override; |
639 | void EmitObjCGlobalAssign(CodeGenFunction &CGF, |
640 | llvm::Value *src, Address dest, |
641 | bool threadlocal=false) override; |
642 | void EmitObjCIvarAssign(CodeGenFunction &CGF, llvm::Value *src, |
643 | Address dest, llvm::Value *ivarOffset) override; |
644 | void EmitObjCStrongCastAssign(CodeGenFunction &CGF, |
645 | llvm::Value *src, Address dest) override; |
646 | void EmitGCMemmoveCollectable(CodeGenFunction &CGF, Address DestPtr, |
647 | Address SrcPtr, |
648 | llvm::Value *Size) override; |
649 | LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy, |
650 | llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, |
651 | unsigned CVRQualifiers) override; |
652 | llvm::Value *EmitIvarOffset(CodeGenFunction &CGF, |
653 | const ObjCInterfaceDecl *Interface, |
654 | const ObjCIvarDecl *Ivar) override; |
655 | llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; |
656 | llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM, |
657 | const CGBlockInfo &blockInfo) override { |
658 | return NULLPtr; |
659 | } |
660 | llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM, |
661 | const CGBlockInfo &blockInfo) override { |
662 | return NULLPtr; |
663 | } |
664 | |
665 | llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override { |
666 | return NULLPtr; |
667 | } |
668 | }; |
669 | |
670 | |
671 | |
672 | |
673 | |
674 | |
675 | |
676 | |
677 | |
678 | class CGObjCGCC : public CGObjCGNU { |
679 | |
680 | |
681 | LazyRuntimeFunction MsgLookupFn; |
682 | |
683 | |
684 | |
685 | LazyRuntimeFunction MsgLookupSuperFn; |
686 | |
687 | protected: |
688 | llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, |
689 | llvm::Value *cmd, llvm::MDNode *node, |
690 | MessageSendInfo &MSI) override { |
691 | CGBuilderTy &Builder = CGF.Builder; |
692 | llvm::Value *args[] = { |
693 | EnforceType(Builder, Receiver, IdTy), |
694 | EnforceType(Builder, cmd, SelectorTy) }; |
695 | llvm::CallBase *imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args); |
696 | imp->setMetadata(msgSendMDKind, node); |
697 | return imp; |
698 | } |
699 | |
700 | llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper, |
701 | llvm::Value *cmd, MessageSendInfo &MSI) override { |
702 | CGBuilderTy &Builder = CGF.Builder; |
703 | llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper, |
704 | PtrToObjCSuperTy).getPointer(), cmd}; |
705 | return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs); |
706 | } |
707 | |
708 | public: |
709 | CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) { |
710 | |
711 | MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy); |
712 | |
713 | MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy, |
714 | PtrToObjCSuperTy, SelectorTy); |
715 | } |
716 | }; |
717 | |
718 | |
719 | class CGObjCGNUstep : public CGObjCGNU { |
720 | |
721 | |
722 | LazyRuntimeFunction SlotLookupFn; |
723 | |
724 | |
725 | |
726 | |
727 | LazyRuntimeFunction SlotLookupSuperFn; |
728 | |
729 | LazyRuntimeFunction SetPropertyAtomic; |
730 | |
731 | LazyRuntimeFunction SetPropertyAtomicCopy; |
732 | |
733 | LazyRuntimeFunction SetPropertyNonAtomic; |
734 | |
735 | LazyRuntimeFunction SetPropertyNonAtomicCopy; |
736 | |
737 | |
738 | LazyRuntimeFunction CxxAtomicObjectGetFn; |
739 | |
740 | |
741 | LazyRuntimeFunction CxxAtomicObjectSetFn; |
742 | |
743 | |
744 | llvm::Type *SlotTy; |
745 | |
746 | llvm::Type *SlotStructTy; |
747 | |
748 | public: |
749 | llvm::Constant *GetEHType(QualType T) override; |
750 | |
751 | protected: |
752 | llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, |
753 | llvm::Value *cmd, llvm::MDNode *node, |
754 | MessageSendInfo &MSI) override { |
755 | CGBuilderTy &Builder = CGF.Builder; |
756 | llvm::FunctionCallee LookupFn = SlotLookupFn; |
757 | |
758 | |
759 | Address ReceiverPtr = |
760 | CGF.CreateTempAlloca(Receiver->getType(), CGF.getPointerAlign()); |
761 | Builder.CreateStore(Receiver, ReceiverPtr); |
762 | |
763 | llvm::Value *self; |
764 | |
765 | if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) { |
766 | self = CGF.LoadObjCSelf(); |
767 | } else { |
768 | self = llvm::ConstantPointerNull::get(IdTy); |
769 | } |
770 | |
771 | |
772 | if (auto *LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee())) |
773 | LookupFn2->addParamAttr(0, llvm::Attribute::NoCapture); |
774 | |
775 | llvm::Value *args[] = { |
776 | EnforceType(Builder, ReceiverPtr.getPointer(), PtrToIdTy), |
777 | EnforceType(Builder, cmd, SelectorTy), |
778 | EnforceType(Builder, self, IdTy) }; |
779 | llvm::CallBase *slot = CGF.EmitRuntimeCallOrInvoke(LookupFn, args); |
780 | slot->setOnlyReadsMemory(); |
781 | slot->setMetadata(msgSendMDKind, node); |
782 | |
783 | |
784 | llvm::Value *imp = Builder.CreateAlignedLoad( |
785 | IMPTy, Builder.CreateStructGEP(SlotStructTy, slot, 4), |
786 | CGF.getPointerAlign()); |
787 | |
788 | |
789 | |
790 | Receiver = Builder.CreateLoad(ReceiverPtr, true); |
791 | return imp; |
792 | } |
793 | |
794 | llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper, |
795 | llvm::Value *cmd, |
796 | MessageSendInfo &MSI) override { |
797 | CGBuilderTy &Builder = CGF.Builder; |
798 | llvm::Value *lookupArgs[] = {ObjCSuper.getPointer(), cmd}; |
799 | |
800 | llvm::CallInst *slot = |
801 | CGF.EmitNounwindRuntimeCall(SlotLookupSuperFn, lookupArgs); |
802 | slot->setOnlyReadsMemory(); |
803 | |
804 | return Builder.CreateAlignedLoad( |
805 | IMPTy, Builder.CreateStructGEP(SlotStructTy, slot, 4), |
806 | CGF.getPointerAlign()); |
807 | } |
808 | |
809 | public: |
810 | CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 9, 3, 1) {} |
811 | CGObjCGNUstep(CodeGenModule &Mod, unsigned ABI, unsigned ProtocolABI, |
812 | unsigned ClassABI) : |
813 | CGObjCGNU(Mod, ABI, ProtocolABI, ClassABI) { |
814 | const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime; |
815 | |
816 | SlotStructTy = llvm::StructType::get(PtrTy, PtrTy, PtrTy, IntTy, IMPTy); |
817 | SlotTy = llvm::PointerType::getUnqual(SlotStructTy); |
818 | |
819 | SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy, |
820 | SelectorTy, IdTy); |
821 | |
822 | SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy, |
823 | PtrToObjCSuperTy, SelectorTy); |
824 | |
825 | if (usesSEHExceptions) { |
826 | llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); |
827 | |
828 | ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy); |
829 | } else if (CGM.getLangOpts().CPlusPlus) { |
830 | llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); |
831 | |
832 | EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy); |
833 | |
834 | ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy); |
835 | |
836 | ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy, |
837 | PtrTy); |
838 | } else if (R.getVersion() >= VersionTuple(1, 7)) { |
839 | llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); |
840 | |
841 | EnterCatchFn.init(&CGM, "objc_begin_catch", IdTy, PtrTy); |
842 | |
843 | ExitCatchFn.init(&CGM, "objc_end_catch", VoidTy); |
844 | |
845 | ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy, PtrTy); |
846 | } |
847 | llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); |
848 | SetPropertyAtomic.init(&CGM, "objc_setProperty_atomic", VoidTy, IdTy, |
849 | SelectorTy, IdTy, PtrDiffTy); |
850 | SetPropertyAtomicCopy.init(&CGM, "objc_setProperty_atomic_copy", VoidTy, |
851 | IdTy, SelectorTy, IdTy, PtrDiffTy); |
852 | SetPropertyNonAtomic.init(&CGM, "objc_setProperty_nonatomic", VoidTy, |
853 | IdTy, SelectorTy, IdTy, PtrDiffTy); |
854 | SetPropertyNonAtomicCopy.init(&CGM, "objc_setProperty_nonatomic_copy", |
855 | VoidTy, IdTy, SelectorTy, IdTy, PtrDiffTy); |
856 | |
857 | |
858 | CxxAtomicObjectSetFn.init(&CGM, "objc_setCppObjectAtomic", VoidTy, PtrTy, |
859 | PtrTy, PtrTy); |
860 | |
861 | |
862 | CxxAtomicObjectGetFn.init(&CGM, "objc_getCppObjectAtomic", VoidTy, PtrTy, |
863 | PtrTy, PtrTy); |
864 | } |
865 | |
866 | llvm::FunctionCallee GetCppAtomicObjectGetFunction() override { |
867 | |
868 | |
869 | assert (CGM.getLangOpts().ObjCRuntime.getVersion() >= |
870 | VersionTuple(1, 7)); |
871 | return CxxAtomicObjectGetFn; |
872 | } |
873 | |
874 | llvm::FunctionCallee GetCppAtomicObjectSetFunction() override { |
875 | |
876 | |
877 | assert (CGM.getLangOpts().ObjCRuntime.getVersion() >= |
878 | VersionTuple(1, 7)); |
879 | return CxxAtomicObjectSetFn; |
880 | } |
881 | |
882 | llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, |
883 | bool copy) override { |
884 | |
885 | |
886 | |
887 | assert ((CGM.getLangOpts().getGC() == LangOptions::NonGC)); |
888 | |
889 | |
890 | assert (CGM.getLangOpts().ObjCRuntime.getVersion() >= |
891 | VersionTuple(1, 7)); |
892 | |
893 | if (atomic) { |
894 | if (copy) return SetPropertyAtomicCopy; |
895 | return SetPropertyAtomic; |
896 | } |
897 | |
898 | return copy ? SetPropertyNonAtomicCopy : SetPropertyNonAtomic; |
899 | } |
900 | }; |
901 | |
902 | |
903 | |
904 | |
905 | class CGObjCGNUstep2 : public CGObjCGNUstep { |
906 | enum SectionKind |
907 | { |
908 | SelectorSection = 0, |
909 | ClassSection, |
910 | ClassReferenceSection, |
911 | CategorySection, |
912 | ProtocolSection, |
913 | ProtocolReferenceSection, |
914 | ClassAliasSection, |
915 | ConstantStringSection |
916 | }; |
917 | static const char *const SectionsBaseNames[8]; |
918 | static const char *const PECOFFSectionsBaseNames[8]; |
919 | template<SectionKind K> |
920 | std::string sectionName() { |
921 | if (CGM.getTriple().isOSBinFormatCOFF()) { |
922 | std::string name(PECOFFSectionsBaseNames[K]); |
923 | name += "$m"; |
924 | return name; |
925 | } |
926 | return SectionsBaseNames[K]; |
927 | } |
928 | |
929 | |
930 | |
931 | LazyRuntimeFunction MsgLookupSuperFn; |
932 | |
933 | |
934 | |
935 | bool EmittedProtocol = false; |
936 | |
937 | |
938 | |
939 | |
940 | bool EmittedProtocolRef = false; |
941 | |
942 | |
943 | |
944 | bool EmittedClass = false; |
945 | |
946 | |
947 | |
948 | typedef std::pair<std::string, std::pair<llvm::GlobalVariable*, int>> |
949 | EarlyInitPair; |
950 | std::vector<EarlyInitPair> EarlyInitList; |
951 | |
952 | std::string SymbolForClassRef(StringRef Name, bool isWeak) { |
953 | if (isWeak) |
954 | return (ManglePublicSymbol("OBJC_WEAK_REF_CLASS_") + Name).str(); |
955 | else |
956 | return (ManglePublicSymbol("OBJC_REF_CLASS_") + Name).str(); |
957 | } |
958 | |
959 | std::string SymbolForClass(StringRef Name) { |
960 | return (ManglePublicSymbol("OBJC_CLASS_") + Name).str(); |
961 | } |
962 | void CallRuntimeFunction(CGBuilderTy &B, StringRef FunctionName, |
963 | ArrayRef<llvm::Value*> Args) { |
964 | SmallVector<llvm::Type *,8> Types; |
965 | for (auto *Arg : Args) |
966 | Types.push_back(Arg->getType()); |
967 | llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types, |
968 | false); |
969 | llvm::FunctionCallee Fn = CGM.CreateRuntimeFunction(FT, FunctionName); |
970 | B.CreateCall(Fn, Args); |
971 | } |
972 | |
973 | ConstantAddress GenerateConstantString(const StringLiteral *SL) override { |
974 | |
975 | auto Str = SL->getString(); |
976 | CharUnits Align = CGM.getPointerAlign(); |
977 | |
978 | |
979 | llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str); |
980 | if (old != ObjCStrings.end()) |
981 | return ConstantAddress(old->getValue(), Align); |
982 | |
983 | bool isNonASCII = SL->containsNonAscii(); |
984 | |
985 | auto LiteralLength = SL->getLength(); |
986 | |
987 | if ((CGM.getTarget().getPointerWidth(0) == 64) && |
988 | (LiteralLength < 9) && !isNonASCII) { |
989 | |
990 | |
991 | |
992 | uint64_t str = 0; |
993 | |
994 | for (unsigned i=0 ; i<LiteralLength ; i++) |
995 | str |= ((uint64_t)SL->getCodeUnit(i)) << ((64 - 4 - 3) - (i*7)); |
996 | |
997 | str |= LiteralLength << 3; |
998 | |
999 | str |= 4; |
1000 | auto *ObjCStr = llvm::ConstantExpr::getIntToPtr( |
1001 | llvm::ConstantInt::get(Int64Ty, str), IdTy); |
1002 | ObjCStrings[Str] = ObjCStr; |
1003 | return ConstantAddress(ObjCStr, Align); |
1004 | } |
1005 | |
1006 | StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass; |
1007 | |
1008 | if (StringClass.empty()) StringClass = "NSConstantString"; |
1009 | |
1010 | std::string Sym = SymbolForClass(StringClass); |
1011 | |
1012 | llvm::Constant *isa = TheModule.getNamedGlobal(Sym); |
1013 | |
1014 | if (!isa) { |
1015 | isa = new llvm::GlobalVariable(TheModule, IdTy, false, |
1016 | llvm::GlobalValue::ExternalLinkage, nullptr, Sym); |
1017 | if (CGM.getTriple().isOSBinFormatCOFF()) { |
1018 | cast<llvm::GlobalValue>(isa)->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); |
1019 | } |
1020 | } else if (isa->getType() != PtrToIdTy) |
1021 | isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy); |
1022 | |
1023 | |
1024 | |
1025 | |
1026 | |
1027 | |
1028 | |
1029 | |
1030 | |
1031 | |
1032 | |
1033 | ConstantInitBuilder Builder(CGM); |
1034 | auto Fields = Builder.beginStruct(); |
1035 | if (!CGM.getTriple().isOSBinFormatCOFF()) { |
1036 | Fields.add(isa); |
1037 | } else { |
1038 | Fields.addNullPointer(PtrTy); |
1039 | } |
1040 | |
1041 | |
1042 | |
1043 | |
1044 | if (isNonASCII) { |
1045 | unsigned NumU8CodeUnits = Str.size(); |
1046 | |
1047 | |
1048 | |
1049 | SmallVector<llvm::UTF16, 128> ToBuf(NumU8CodeUnits + 1); |
1050 | const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)Str.data(); |
1051 | llvm::UTF16 *ToPtr = &ToBuf[0]; |
1052 | (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumU8CodeUnits, |
1053 | &ToPtr, ToPtr + NumU8CodeUnits, llvm::strictConversion); |
1054 | uint32_t StringLength = ToPtr - &ToBuf[0]; |
1055 | |
1056 | *ToPtr = 0; |
1057 | |
1058 | Fields.addInt(Int32Ty, 2); |
1059 | |
1060 | Fields.addInt(Int32Ty, StringLength); |
1061 | |
1062 | Fields.addInt(Int32Ty, StringLength * 2); |
1063 | |
1064 | Fields.addInt(Int32Ty, 0); |
1065 | |
1066 | auto Arr = llvm::makeArrayRef(&ToBuf[0], ToPtr+1); |
1067 | auto *C = llvm::ConstantDataArray::get(VMContext, Arr); |
1068 | auto *Buffer = new llvm::GlobalVariable(TheModule, C->getType(), |
1069 | true, llvm::GlobalValue::PrivateLinkage, C, ".str"); |
1070 | Buffer->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); |
1071 | Fields.add(Buffer); |
1072 | } else { |
1073 | |
1074 | Fields.addInt(Int32Ty, 0); |
1075 | |
1076 | Fields.addInt(Int32Ty, Str.size()); |
1077 | |
1078 | Fields.addInt(Int32Ty, Str.size()); |
1079 | |
1080 | Fields.addInt(Int32Ty, 0); |
1081 | |
1082 | Fields.add(MakeConstantString(Str)); |
1083 | } |
1084 | std::string StringName; |
1085 | bool isNamed = !isNonASCII; |
1086 | if (isNamed) { |
1087 | StringName = ".objc_str_"; |
1088 | for (int i=0,e=Str.size() ; i<e ; ++i) { |
1089 | unsigned char c = Str[i]; |
1090 | if (isalnum(c)) |
1091 | StringName += c; |
1092 | else if (c == ' ') |
1093 | StringName += '_'; |
1094 | else { |
1095 | isNamed = false; |
1096 | break; |
1097 | } |
1098 | } |
1099 | } |
1100 | llvm::GlobalVariable *ObjCStrGV = |
1101 | Fields.finishAndCreateGlobal( |
1102 | isNamed ? StringRef(StringName) : ".objc_string", |
1103 | Align, false, isNamed ? llvm::GlobalValue::LinkOnceODRLinkage |
1104 | : llvm::GlobalValue::PrivateLinkage); |
1105 | ObjCStrGV->setSection(sectionName<ConstantStringSection>()); |
1106 | if (isNamed) { |
1107 | ObjCStrGV->setComdat(TheModule.getOrInsertComdat(StringName)); |
1108 | ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1109 | } |
1110 | if (CGM.getTriple().isOSBinFormatCOFF()) { |
1111 | std::pair<llvm::GlobalVariable*, int> v{ObjCStrGV, 0}; |
1112 | EarlyInitList.emplace_back(Sym, v); |
1113 | } |
1114 | llvm::Constant *ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStrGV, IdTy); |
1115 | ObjCStrings[Str] = ObjCStr; |
1116 | ConstantStrings.push_back(ObjCStr); |
1117 | return ConstantAddress(ObjCStr, Align); |
1118 | } |
1119 | |
1120 | void PushProperty(ConstantArrayBuilder &PropertiesArray, |
1121 | const ObjCPropertyDecl *property, |
1122 | const Decl *OCD, |
1123 | bool isSynthesized=true, bool |
1124 | isDynamic=true) override { |
1125 | |
1126 | |
1127 | |
1128 | |
1129 | |
1130 | |
1131 | |
1132 | |
1133 | auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy); |
1134 | ASTContext &Context = CGM.getContext(); |
1135 | Fields.add(MakeConstantString(property->getNameAsString())); |
1136 | std::string TypeStr = |
1137 | CGM.getContext().getObjCEncodingForPropertyDecl(property, OCD); |
1138 | Fields.add(MakeConstantString(TypeStr)); |
1139 | std::string typeStr; |
1140 | Context.getObjCEncodingForType(property->getType(), typeStr); |
1141 | Fields.add(MakeConstantString(typeStr)); |
1142 | auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) { |
1143 | if (accessor) { |
1144 | std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor); |
1145 | Fields.add(GetConstantSelector(accessor->getSelector(), TypeStr)); |
1146 | } else { |
1147 | Fields.add(NULLPtr); |
1148 | } |
1149 | }; |
1150 | addPropertyMethod(property->getGetterMethodDecl()); |
1151 | addPropertyMethod(property->getSetterMethodDecl()); |
1152 | Fields.finishAndAddTo(PropertiesArray); |
1153 | } |
1154 | |
1155 | llvm::Constant * |
1156 | GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) override { |
1157 | |
1158 | |
1159 | |
1160 | |
1161 | |
1162 | llvm::StructType *ObjCMethodDescTy = |
1163 | llvm::StructType::get(CGM.getLLVMContext(), |
1164 | { PtrToInt8Ty, PtrToInt8Ty }); |
1165 | ASTContext &Context = CGM.getContext(); |
1166 | ConstantInitBuilder Builder(CGM); |
1167 | |
1168 | |
1169 | |
1170 | |
1171 | |
1172 | |
1173 | auto MethodList = Builder.beginStruct(); |
1174 | |
1175 | MethodList.addInt(IntTy, Methods.size()); |
1176 | |
1177 | llvm::DataLayout td(&TheModule); |
1178 | MethodList.addInt(IntTy, td.getTypeSizeInBits(ObjCMethodDescTy) / |
1179 | CGM.getContext().getCharWidth()); |
1180 | |
1181 | auto MethodArray = MethodList.beginArray(ObjCMethodDescTy); |
1182 | for (auto *M : Methods) { |
1183 | auto Method = MethodArray.beginStruct(ObjCMethodDescTy); |
1184 | Method.add(CGObjCGNU::GetConstantSelector(M)); |
1185 | Method.add(GetTypeString(Context.getObjCEncodingForMethodDecl(M, true))); |
1186 | Method.finishAndAddTo(MethodArray); |
1187 | } |
1188 | MethodArray.finishAndAddTo(MethodList); |
1189 | return MethodList.finishAndCreateGlobal(".objc_protocol_method_list", |
1190 | CGM.getPointerAlign()); |
1191 | } |
1192 | llvm::Constant *GenerateCategoryProtocolList(const ObjCCategoryDecl *OCD) |
1193 | override { |
1194 | const auto &ReferencedProtocols = OCD->getReferencedProtocols(); |
1195 | auto RuntimeProtocols = GetRuntimeProtocolList(ReferencedProtocols.begin(), |
1196 | ReferencedProtocols.end()); |
1197 | SmallVector<llvm::Constant *, 16> Protocols; |
1198 | for (const auto *PI : RuntimeProtocols) |
1199 | Protocols.push_back( |
1200 | llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI), |
1201 | ProtocolPtrTy)); |
1202 | return GenerateProtocolList(Protocols); |
1203 | } |
1204 | |
1205 | llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper, |
1206 | llvm::Value *cmd, MessageSendInfo &MSI) override { |
1207 | |
1208 | CGBuilderTy &Builder = CGF.Builder; |
1209 | llvm::Value *lookupArgs[] = {CGObjCGNU::EnforceType(Builder, ObjCSuper, |
1210 | PtrToObjCSuperTy).getPointer(), cmd}; |
1211 | return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs); |
1212 | } |
1213 | |
1214 | llvm::GlobalVariable *GetClassVar(StringRef Name, bool isWeak=false) { |
1215 | std::string SymbolName = SymbolForClassRef(Name, isWeak); |
1216 | auto *ClassSymbol = TheModule.getNamedGlobal(SymbolName); |
1217 | if (ClassSymbol) |
| 13 | | Assuming 'ClassSymbol' is null | |
|
| |
1218 | return ClassSymbol; |
1219 | ClassSymbol = new llvm::GlobalVariable(TheModule, |
1220 | IdTy, false, llvm::GlobalValue::ExternalLinkage, |
1221 | nullptr, SymbolName); |
1222 | |
1223 | |
1224 | |
1225 | |
1226 | if (isWeak) |
| |
1227 | ClassSymbol->setInitializer(new llvm::GlobalVariable(TheModule, |
1228 | Int8Ty, false, llvm::GlobalValue::ExternalWeakLinkage, |
1229 | nullptr, SymbolForClass(Name))); |
1230 | else { |
1231 | if (CGM.getTriple().isOSBinFormatCOFF()) { |
| 16 | | Calling 'Triple::isOSBinFormatCOFF' | |
|
| 18 | | Returning from 'Triple::isOSBinFormatCOFF' | |
|
| |
1232 | IdentifierInfo &II = CGM.getContext().Idents.get(Name); |
1233 | TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); |
1234 | DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); |
1235 | |
1236 | const ObjCInterfaceDecl *OID = nullptr; |
| 20 | | 'OID' initialized to a null pointer value | |
|
1237 | for (const auto *Result : DC->lookup(&II)) |
1238 | if ((OID = dyn_cast<ObjCInterfaceDecl>(Result))) |
1239 | break; |
1240 | |
1241 | |
1242 | |
1243 | |
1244 | assert(OID && "Failed to find ObjCInterfaceDecl"); |
1245 | const ObjCInterfaceDecl *OIDDef = OID->getDefinition(); |
| 21 | | Called C++ object pointer is null |
|
1246 | if (OIDDef != nullptr) |
1247 | OID = OIDDef; |
1248 | |
1249 | auto Storage = llvm::GlobalValue::DefaultStorageClass; |
1250 | if (OID->hasAttr<DLLImportAttr>()) |
1251 | Storage = llvm::GlobalValue::DLLImportStorageClass; |
1252 | else if (OID->hasAttr<DLLExportAttr>()) |
1253 | Storage = llvm::GlobalValue::DLLExportStorageClass; |
1254 | |
1255 | cast<llvm::GlobalValue>(ClassSymbol)->setDLLStorageClass(Storage); |
1256 | } |
1257 | } |
1258 | assert(ClassSymbol->getName() == SymbolName); |
1259 | return ClassSymbol; |
1260 | } |
1261 | llvm::Value *GetClassNamed(CodeGenFunction &CGF, |
1262 | const std::string &Name, |
1263 | bool isWeak) override { |
1264 | return CGF.Builder.CreateLoad(Address(GetClassVar(Name, isWeak), |
1265 | CGM.getPointerAlign())); |
1266 | } |
1267 | int32_t FlagsForOwnership(Qualifiers::ObjCLifetime Ownership) { |
1268 | |
1269 | |
1270 | |
1271 | |
1272 | |
1273 | |
1274 | int Flag; |
1275 | switch (Ownership) { |
1276 | case Qualifiers::OCL_Strong: |
1277 | Flag = 1; |
1278 | break; |
1279 | case Qualifiers::OCL_Weak: |
1280 | Flag = 2; |
1281 | break; |
1282 | case Qualifiers::OCL_ExplicitNone: |
1283 | Flag = 3; |
1284 | break; |
1285 | case Qualifiers::OCL_None: |
1286 | case Qualifiers::OCL_Autoreleasing: |
1287 | assert(Ownership != Qualifiers::OCL_Autoreleasing); |
1288 | Flag = 0; |
1289 | } |
1290 | return Flag; |
1291 | } |
1292 | llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames, |
1293 | ArrayRef<llvm::Constant *> IvarTypes, |
1294 | ArrayRef<llvm::Constant *> IvarOffsets, |
1295 | ArrayRef<llvm::Constant *> IvarAlign, |
1296 | ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) override { |
1297 | llvm_unreachable("Method should not be called!"); |
1298 | } |
1299 | |
1300 | llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName) override { |
1301 | std::string Name = SymbolForProtocol(ProtocolName); |
1302 | auto *GV = TheModule.getGlobalVariable(Name); |
1303 | if (!GV) { |
1304 | |
1305 | GV = new llvm::GlobalVariable(TheModule, ProtocolTy, false, |
1306 | llvm::GlobalValue::ExternalLinkage, nullptr, Name); |
1307 | GV->setAlignment(CGM.getPointerAlign().getAsAlign()); |
1308 | } |
1309 | return llvm::ConstantExpr::getBitCast(GV, ProtocolPtrTy); |
1310 | } |
1311 | |
1312 | |
1313 | llvm::StringMap<llvm::Constant*> ExistingProtocolRefs; |
1314 | |
1315 | llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, |
1316 | const ObjCProtocolDecl *PD) override { |
1317 | auto Name = PD->getNameAsString(); |
1318 | auto *&Ref = ExistingProtocolRefs[Name]; |
1319 | if (!Ref) { |
1320 | auto *&Protocol = ExistingProtocols[Name]; |
1321 | if (!Protocol) |
1322 | Protocol = GenerateProtocolRef(PD); |
1323 | std::string RefName = SymbolForProtocolRef(Name); |
1324 | assert(!TheModule.getGlobalVariable(RefName)); |
1325 | |
1326 | auto GV = new llvm::GlobalVariable(TheModule, ProtocolPtrTy, |
1327 | false, llvm::GlobalValue::LinkOnceODRLinkage, |
1328 | llvm::ConstantExpr::getBitCast(Protocol, ProtocolPtrTy), RefName); |
1329 | GV->setComdat(TheModule.getOrInsertComdat(RefName)); |
1330 | GV->setSection(sectionName<ProtocolReferenceSection>()); |
1331 | GV->setAlignment(CGM.getPointerAlign().getAsAlign()); |
1332 | Ref = GV; |
1333 | } |
1334 | EmittedProtocolRef = true; |
1335 | return CGF.Builder.CreateAlignedLoad(ProtocolPtrTy, Ref, |
1336 | CGM.getPointerAlign()); |
1337 | } |
1338 | |
1339 | llvm::Constant *GenerateProtocolList(ArrayRef<llvm::Constant*> Protocols) { |
1340 | llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(ProtocolPtrTy, |
1341 | Protocols.size()); |
1342 | llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy, |
1343 | Protocols); |
1344 | ConstantInitBuilder builder(CGM); |
1345 | auto ProtocolBuilder = builder.beginStruct(); |
1346 | ProtocolBuilder.addNullPointer(PtrTy); |
1347 | ProtocolBuilder.addInt(SizeTy, Protocols.size()); |
1348 | ProtocolBuilder.add(ProtocolArray); |
1349 | return ProtocolBuilder.finishAndCreateGlobal(".objc_protocol_list", |
1350 | CGM.getPointerAlign(), false, llvm::GlobalValue::InternalLinkage); |
1351 | } |
1352 | |
1353 | void GenerateProtocol(const ObjCProtocolDecl *PD) override { |
1354 | |
1355 | } |
1356 | llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD) override { |
1357 | std::string ProtocolName = PD->getNameAsString(); |
1358 | auto *&Protocol = ExistingProtocols[ProtocolName]; |
1359 | if (Protocol) |
1360 | return Protocol; |
1361 | |
1362 | EmittedProtocol = true; |
1363 | |
1364 | auto SymName = SymbolForProtocol(ProtocolName); |
1365 | auto *OldGV = TheModule.getGlobalVariable(SymName); |
1366 | |
1367 | |
1368 | if (const ObjCProtocolDecl *Def = PD->getDefinition()) |
1369 | PD = Def; |
1370 | else { |
1371 | |
1372 | |
1373 | |
1374 | assert(!OldGV); |
1375 | Protocol = new llvm::GlobalVariable(TheModule, ProtocolTy, |
1376 | false, |
1377 | llvm::GlobalValue::ExternalLinkage, nullptr, SymName); |
1378 | return Protocol; |
1379 | } |
1380 | |
1381 | SmallVector<llvm::Constant*, 16> Protocols; |
1382 | auto RuntimeProtocols = |
1383 | GetRuntimeProtocolList(PD->protocol_begin(), PD->protocol_end()); |
1384 | for (const auto *PI : RuntimeProtocols) |
1385 | Protocols.push_back( |
1386 | llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI), |
1387 | ProtocolPtrTy)); |
1388 | llvm::Constant *ProtocolList = GenerateProtocolList(Protocols); |
1389 | |
1390 | |
1391 | llvm::Constant *InstanceMethodList, *OptionalInstanceMethodList; |
1392 | llvm::Constant *ClassMethodList, *OptionalClassMethodList; |
1393 | EmitProtocolMethodList(PD->instance_methods(), InstanceMethodList, |
1394 | OptionalInstanceMethodList); |
1395 | EmitProtocolMethodList(PD->class_methods(), ClassMethodList, |
1396 | OptionalClassMethodList); |
1397 | |
1398 | |
1399 | |
1400 | ConstantInitBuilder builder(CGM); |
1401 | auto ProtocolBuilder = builder.beginStruct(); |
1402 | ProtocolBuilder.add(llvm::ConstantExpr::getIntToPtr( |
1403 | llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy)); |
1404 | ProtocolBuilder.add(MakeConstantString(ProtocolName)); |
1405 | ProtocolBuilder.add(ProtocolList); |
1406 | ProtocolBuilder.add(InstanceMethodList); |
1407 | ProtocolBuilder.add(ClassMethodList); |
1408 | ProtocolBuilder.add(OptionalInstanceMethodList); |
1409 | ProtocolBuilder.add(OptionalClassMethodList); |
1410 | |
1411 | ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, false)); |
1412 | |
1413 | ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, true)); |
1414 | |
1415 | ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, false)); |
1416 | |
1417 | ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, true)); |
1418 | |
1419 | auto *GV = ProtocolBuilder.finishAndCreateGlobal(SymName, |
1420 | CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage); |
1421 | GV->setSection(sectionName<ProtocolSection>()); |
1422 | GV->setComdat(TheModule.getOrInsertComdat(SymName)); |
1423 | if (OldGV) { |
1424 | OldGV->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GV, |
1425 | OldGV->getType())); |
1426 | OldGV->removeFromParent(); |
1427 | GV->setName(SymName); |
1428 | } |
1429 | Protocol = GV; |
1430 | return GV; |
1431 | } |
1432 | llvm::Constant *EnforceType(llvm::Constant *Val, llvm::Type *Ty) { |
1433 | if (Val->getType() == Ty) |
1434 | return Val; |
1435 | return llvm::ConstantExpr::getBitCast(Val, Ty); |
1436 | } |
1437 | llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel, |
1438 | const std::string &TypeEncoding) override { |
1439 | return GetConstantSelector(Sel, TypeEncoding); |
1440 | } |
1441 | llvm::Constant *GetTypeString(llvm::StringRef TypeEncoding) { |
1442 | if (TypeEncoding.empty()) |
1443 | return NULLPtr; |
1444 | std::string MangledTypes = std::string(TypeEncoding); |
1445 | std::replace(MangledTypes.begin(), MangledTypes.end(), |
1446 | '@', '\1'); |
1447 | std::string TypesVarName = ".objc_sel_types_" + MangledTypes; |
1448 | auto *TypesGlobal = TheModule.getGlobalVariable(TypesVarName); |
1449 | if (!TypesGlobal) { |
1450 | llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext, |
1451 | TypeEncoding); |
1452 | auto *GV = new llvm::GlobalVariable(TheModule, Init->getType(), |
1453 | true, llvm::GlobalValue::LinkOnceODRLinkage, Init, TypesVarName); |
1454 | GV->setComdat(TheModule.getOrInsertComdat(TypesVarName)); |
1455 | GV->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1456 | TypesGlobal = GV; |
1457 | } |
1458 | return llvm::ConstantExpr::getGetElementPtr(TypesGlobal->getValueType(), |
1459 | TypesGlobal, Zeros); |
1460 | } |
1461 | llvm::Constant *GetConstantSelector(Selector Sel, |
1462 | const std::string &TypeEncoding) override { |
1463 | |
1464 | |
1465 | |
1466 | |
1467 | std::string MangledTypes = TypeEncoding; |
1468 | std::replace(MangledTypes.begin(), MangledTypes.end(), |
1469 | '@', '\1'); |
1470 | auto SelVarName = (StringRef(".objc_selector_") + Sel.getAsString() + "_" + |
1471 | MangledTypes).str(); |
1472 | if (auto *GV = TheModule.getNamedGlobal(SelVarName)) |
1473 | return EnforceType(GV, SelectorTy); |
1474 | ConstantInitBuilder builder(CGM); |
1475 | auto SelBuilder = builder.beginStruct(); |
1476 | SelBuilder.add(ExportUniqueString(Sel.getAsString(), ".objc_sel_name_", |
1477 | true)); |
1478 | SelBuilder.add(GetTypeString(TypeEncoding)); |
1479 | auto *GV = SelBuilder.finishAndCreateGlobal(SelVarName, |
1480 | CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage); |
1481 | GV->setComdat(TheModule.getOrInsertComdat(SelVarName)); |
1482 | GV->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1483 | GV->setSection(sectionName<SelectorSection>()); |
1484 | auto *SelVal = EnforceType(GV, SelectorTy); |
1485 | return SelVal; |
1486 | } |
1487 | llvm::StructType *emptyStruct = nullptr; |
1488 | |
1489 | |
1490 | |
1491 | |
1492 | |
1493 | |
1494 | |
1495 | |
1496 | std::pair<llvm::Constant*,llvm::Constant*> |
1497 | GetSectionBounds(StringRef Section) { |
1498 | if (CGM.getTriple().isOSBinFormatCOFF()) { |
1499 | if (emptyStruct == nullptr) { |
1500 | emptyStruct = llvm::StructType::create(VMContext, ".objc_section_sentinel"); |
1501 | emptyStruct->setBody({}, true); |
1502 | } |
1503 | auto ZeroInit = llvm::Constant::getNullValue(emptyStruct); |
1504 | auto Sym = [&](StringRef Prefix, StringRef SecSuffix) { |
1505 | auto *Sym = new llvm::GlobalVariable(TheModule, emptyStruct, |
1506 | false, |
1507 | llvm::GlobalValue::LinkOnceODRLinkage, ZeroInit, Prefix + |
1508 | Section); |
1509 | Sym->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1510 | Sym->setSection((Section + SecSuffix).str()); |
1511 | Sym->setComdat(TheModule.getOrInsertComdat((Prefix + |
1512 | Section).str())); |
1513 | Sym->setAlignment(CGM.getPointerAlign().getAsAlign()); |
1514 | return Sym; |
1515 | }; |
1516 | return { Sym("__start_", "$a"), Sym("__stop", "$z") }; |
1517 | } |
1518 | auto *Start = new llvm::GlobalVariable(TheModule, PtrTy, |
1519 | false, |
1520 | llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__start_") + |
1521 | Section); |
1522 | Start->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1523 | auto *Stop = new llvm::GlobalVariable(TheModule, PtrTy, |
1524 | false, |
1525 | llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__stop_") + |
1526 | Section); |
1527 | Stop->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1528 | return { Start, Stop }; |
1529 | } |
1530 | CatchTypeInfo getCatchAllTypeInfo() override { |
1531 | return CGM.getCXXABI().getCatchAllTypeInfo(); |
1532 | } |
1533 | llvm::Function *ModuleInitFunction() override { |
1534 | llvm::Function *LoadFunction = llvm::Function::Create( |
1535 | llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false), |
1536 | llvm::GlobalValue::LinkOnceODRLinkage, ".objcv2_load_function", |
1537 | &TheModule); |
1538 | LoadFunction->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1539 | LoadFunction->setComdat(TheModule.getOrInsertComdat(".objcv2_load_function")); |
1540 | |
1541 | llvm::BasicBlock *EntryBB = |
1542 | llvm::BasicBlock::Create(VMContext, "entry", LoadFunction); |
1543 | CGBuilderTy B(CGM, VMContext); |
1544 | B.SetInsertPoint(EntryBB); |
1545 | ConstantInitBuilder builder(CGM); |
1546 | auto InitStructBuilder = builder.beginStruct(); |
1547 | InitStructBuilder.addInt(Int64Ty, 0); |
1548 | auto §ionVec = CGM.getTriple().isOSBinFormatCOFF() ? PECOFFSectionsBaseNames : SectionsBaseNames; |
1549 | for (auto *s : sectionVec) { |
1550 | auto bounds = GetSectionBounds(s); |
1551 | InitStructBuilder.add(bounds.first); |
1552 | InitStructBuilder.add(bounds.second); |
1553 | } |
1554 | auto *InitStruct = InitStructBuilder.finishAndCreateGlobal(".objc_init", |
1555 | CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage); |
1556 | InitStruct->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1557 | InitStruct->setComdat(TheModule.getOrInsertComdat(".objc_init")); |
1558 | |
1559 | CallRuntimeFunction(B, "__objc_load", {InitStruct});; |
1560 | B.CreateRetVoid(); |
1561 | |
1562 | CGM.addCompilerUsedGlobal(LoadFunction); |
1563 | |
1564 | |
1565 | |
1566 | auto *InitVar = new llvm::GlobalVariable(TheModule, LoadFunction->getType(), |
1567 | false, llvm::GlobalValue::LinkOnceAnyLinkage, |
1568 | LoadFunction, ".objc_ctor"); |
1569 | |
1570 | |
1571 | assert(InitVar->getName() == ".objc_ctor"); |
1572 | |
1573 | |
1574 | |
1575 | |
1576 | |
1577 | if (CGM.getTriple().isOSBinFormatCOFF()) |
1578 | InitVar->setSection(".CRT$XCLz"); |
1579 | else |
1580 | { |
1581 | if (CGM.getCodeGenOpts().UseInitArray) |
1582 | InitVar->setSection(".init_array"); |
1583 | else |
1584 | InitVar->setSection(".ctors"); |
1585 | } |
1586 | InitVar->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1587 | InitVar->setComdat(TheModule.getOrInsertComdat(".objc_ctor")); |
1588 | CGM.addUsedGlobal(InitVar); |
1589 | for (auto *C : Categories) { |
1590 | auto *Cat = cast<llvm::GlobalVariable>(C->stripPointerCasts()); |
1591 | Cat->setSection(sectionName<CategorySection>()); |
1592 | CGM.addUsedGlobal(Cat); |
1593 | } |
1594 | auto createNullGlobal = [&](StringRef Name, ArrayRef<llvm::Constant*> Init, |
1595 | StringRef Section) { |
1596 | auto nullBuilder = builder.beginStruct(); |
1597 | for (auto *F : Init) |
1598 | nullBuilder.add(F); |
1599 | auto GV = nullBuilder.finishAndCreateGlobal(Name, CGM.getPointerAlign(), |
1600 | false, llvm::GlobalValue::LinkOnceODRLinkage); |
1601 | GV->setSection(Section); |
1602 | GV->setComdat(TheModule.getOrInsertComdat(Name)); |
1603 | GV->setVisibility(llvm::GlobalValue::HiddenVisibility); |
1604 | CGM.addUsedGlobal(GV); |
1605 | return GV; |
1606 | }; |
1607 | for (auto clsAlias : ClassAliases) |
1608 | createNullGlobal(std::string(".objc_class_alias") + |
1609 | clsAlias.second, { MakeConstantString(clsAlias.second), |
1610 | GetClassVar(clsAlias.first) }, sectionName<ClassAliasSection>()); |
1611 | |
1612 | |
1613 | |
1614 | |
1615 | if (!CGM.getTriple().isOSBinFormatCOFF()) { |
1616 | createNullGlobal(".objc_null_selector", {NULLPtr, NULLPtr}, |
1617 | sectionName<SelectorSection>()); |
1618 | if (Categories.empty()) |
1619 | createNullGlobal(".objc_null_category", {NULLPtr, NULLPtr, |
1620 | NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr}, |
1621 | sectionName<CategorySection>()); |
1622 | if (!EmittedClass) { |
1623 | createNullGlobal(".objc_null_cls_init_ref", NULLPtr, |
1624 | sectionName<ClassSection>()); |
1625 | createNullGlobal(".objc_null_class_ref", { NULLPtr, NULLPtr }, |
1626 | sectionName<ClassReferenceSection>()); |
1627 | } |
1628 | if (!EmittedProtocol) |
1629 | createNullGlobal(".objc_null_protocol", {NULLPtr, NULLPtr, NULLPtr, |
1630 | NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, |
1631 | NULLPtr}, sectionName<ProtocolSection>()); |
1632 | if (!EmittedProtocolRef) |
1633 | createNullGlobal(".objc_null_protocol_ref", {NULLPtr}, |
1634 | sectionName<ProtocolReferenceSection>()); |
1635 | if (ClassAliases.empty()) |
1636 | createNullGlobal(".objc_null_class_alias", { NULLPtr, NULLPtr }, |
1637 | sectionName<ClassAliasSection>()); |
1638 | if (ConstantStrings.empty()) { |
1639 | auto i32Zero = llvm::ConstantInt::get(Int32Ty, 0); |
1640 | createNullGlobal(".objc_null_constant_string", { NULLPtr, i32Zero, |
1641 | i32Zero, i32Zero, i32Zero, NULLPtr }, |
1642 | sectionName<ConstantStringSection>()); |
1643 | } |
1644 | } |
1645 | ConstantStrings.clear(); |
1646 | Categories.clear(); |
1647 | Classes.clear(); |
1648 | |
1649 | if (EarlyInitList.size() > 0) { |
1650 | auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy, |
1651 | {}), llvm::GlobalValue::InternalLinkage, ".objc_early_init", |
1652 | &CGM.getModule()); |
1653 | llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry", |
1654 | Init)); |
1655 | for (const auto &lateInit : EarlyInitList) { |
1656 | auto *global = TheModule.getGlobalVariable(lateInit.first); |
1657 | if (global) { |
1658 | llvm::GlobalVariable *GV = lateInit.second.first; |
1659 | b.CreateAlignedStore( |
1660 | global, |
1661 | b.CreateStructGEP(GV->getValueType(), GV, lateInit.second.second), |
1662 | CGM.getPointerAlign().getAsAlign()); |
1663 | } |
1664 | } |
1665 | b.CreateRetVoid(); |
1666 | |
1667 | |
1668 | auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), |
1669 | true, llvm::GlobalValue::InternalLinkage, |
1670 | Init, ".objc_early_init_ptr"); |
1671 | InitVar->setSection(".CRT$XCLb"); |
1672 | CGM.addUsedGlobal(InitVar); |
1673 | } |
1674 | return nullptr; |
1675 | } |
1676 | |
1677 | |
1678 | std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID, |
1679 | const ObjCIvarDecl *Ivar) override { |
1680 | std::string TypeEncoding; |
1681 | CGM.getContext().getObjCEncodingForType(Ivar->getType(), TypeEncoding); |
1682 | |
1683 | std::replace(TypeEncoding.begin(), TypeEncoding.end(), |
1684 | '@', '\1'); |
1685 | const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString() |
1686 | + '.' + Ivar->getNameAsString() + '.' + TypeEncoding; |
1687 | return Name; |
1688 | } |
1689 | llvm::Value *EmitIvarOffset(CodeGenFunction &CGF, |
1690 | const ObjCInterfaceDecl *Interface, |
1691 | const ObjCIvarDecl *Ivar) override { |
1692 | const std::string Name = GetIVarOffsetVariableName(Ivar->getContainingInterface(), Ivar); |
1693 | llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name); |
1694 | if (!IvarOffsetPointer) |
1695 | IvarOffsetPointer = new llvm::GlobalVariable(TheModule, IntTy, false, |
1696 | llvm::GlobalValue::ExternalLinkage, nullptr, Name); |
1697 | CharUnits Align = CGM.getIntAlign(); |
1698 | llvm::Value *Offset = |
1699 | CGF.Builder.CreateAlignedLoad(IntTy, IvarOffsetPointer, Align); |
1700 | if (Offset->getType() != PtrDiffTy) |
1701 | Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy); |
1702 | return Offset; |
1703 | } |
1704 | void GenerateClass(const ObjCImplementationDecl *OID) override { |
1705 | ASTContext &Context = CGM.getContext(); |
1706 | bool IsCOFF = CGM.getTriple().isOSBinFormatCOFF(); |
1707 | |
1708 | |
1709 | ObjCInterfaceDecl *classDecl = |
1710 | const_cast<ObjCInterfaceDecl *>(OID->getClassInterface()); |
1711 | std::string className = classDecl->getNameAsString(); |
1712 | auto *classNameConstant = MakeConstantString(className); |
1713 | |
1714 | ConstantInitBuilder builder(CGM); |
1715 | auto metaclassFields = builder.beginStruct(); |
1716 | |
1717 | metaclassFields.addNullPointer(PtrTy); |
1718 | |
1719 | metaclassFields.addNullPointer(PtrTy); |
1720 | |
1721 | metaclassFields.add(classNameConstant); |
1722 | |
1723 | metaclassFields.addInt(LongTy, 0); |
1724 | |
1725 | |
1726 | metaclassFields.addInt(LongTy, 1); |
1727 | |
1728 | |
1729 | |
1730 | metaclassFields.addInt(LongTy, 0); |
1731 | |
1732 | metaclassFields.addNullPointer(PtrTy); |
1733 | |
1734 | |
1735 | |
1736 | if (OID->classmeth_begin() == OID->classmeth_end()) |
| |
1737 | metaclassFields.addNullPointer(PtrTy); |
1738 | else { |
1739 | SmallVector<ObjCMethodDecl*, 16> ClassMethods; |
1740 | ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(), |
1741 | OID->classmeth_end()); |
1742 | metaclassFields.addBitCast( |
1743 | GenerateMethodList(className, "", ClassMethods, true), |
1744 | PtrTy); |
1745 | } |
1746 | |
1747 | metaclassFields.addNullPointer(PtrTy); |
1748 | |
1749 | metaclassFields.addNullPointer(PtrTy); |
1750 | |
1751 | metaclassFields.addNullPointer(PtrTy); |
1752 | |
1753 | metaclassFields.addNullPointer(PtrTy); |
1754 | |
1755 | metaclassFields.addNullPointer(PtrTy); |
1756 | |
1757 | metaclassFields.addNullPointer(PtrTy); |
1758 | |
1759 | metaclassFields.addNullPointer(PtrTy); |
1760 | |
1761 | metaclassFields.addInt(LongTy, 0); |
1762 | |
1763 | metaclassFields.add(GeneratePropertyList(OID, classDecl, true)); |
1764 | |
1765 | auto *metaclass = metaclassFields.finishAndCreateGlobal( |
1766 | ManglePublicSymbol("OBJC_METACLASS_") + className, |
1767 | CGM.getPointerAlign()); |
1768 | |
1769 | auto classFields = builder.beginStruct(); |
1770 | |
1771 | classFields.add(metaclass); |
1772 | |
1773 | |
1774 | const ObjCInterfaceDecl * SuperClassDecl = |
1775 | OID->getClassInterface()->getSuperClass(); |
1776 | llvm::Constant *SuperClass = nullptr; |
1777 | if (SuperClassDecl) { |
| 2 | | Assuming 'SuperClassDecl' is null | |
|
| |
1778 | auto SuperClassName = SymbolForClass(SuperClassDecl->getNameAsString()); |
1779 | SuperClass = TheModule.getNamedGlobal(SuperClassName); |
1780 | if (!SuperClass) |
1781 | { |
1782 | SuperClass = new llvm::GlobalVariable(TheModule, PtrTy, false, |
1783 | llvm::GlobalValue::ExternalLinkage, nullptr, SuperClassName); |
1784 | if (IsCOFF) { |
1785 | auto Storage = llvm::GlobalValue::DefaultStorageClass; |
1786 | if (SuperClassDecl->hasAttr<DLLImportAttr>()) |
1787 | Storage = llvm::GlobalValue::DLLImportStorageClass; |
1788 | else if (SuperClassDecl->hasAttr<DLLExportAttr>()) |
1789 | Storage = llvm::GlobalValue::DLLExportStorageClass; |
1790 | |
1791 | cast<llvm::GlobalValue>(SuperClass)->setDLLStorageClass(Storage); |
1792 | } |
1793 | } |
1794 | if (!IsCOFF) |
1795 | classFields.add(llvm::ConstantExpr::getBitCast(SuperClass, PtrTy)); |
1796 | else |
1797 | classFields.addNullPointer(PtrTy); |
1798 | } else |
1799 | classFields.addNullPointer(PtrTy); |
1800 | |
1801 | classFields.add(classNameConstant); |
1802 | |
1803 | classFields.addInt(LongTy, 0); |
1804 | |
1805 | |
1806 | classFields.addInt(LongTy, 0); |
1807 | |
1808 | int superInstanceSize = !SuperClassDecl ? 0 : |
| |
1809 | Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity(); |
1810 | |
1811 | |
1812 | classFields.addInt(LongTy, |
1813 | 0 - (Context.getASTObjCImplementationLayout(OID).getSize().getQuantity() - |
1814 | superInstanceSize)); |
1815 | |
1816 | if (classDecl->all_declared_ivar_begin() == nullptr) |
| 5 | | Assuming the condition is false | |
|
| |
1817 | classFields.addNullPointer(PtrTy); |
1818 | else { |
1819 | int ivar_count = 0; |
1820 | for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD; |
| 7 | | Loop condition is false. Execution continues on line 1822 | |
|
1821 | IVD = IVD->getNextIvar()) ivar_count++; |
1822 | llvm::DataLayout td(&TheModule); |
1823 | |
1824 | ConstantInitBuilder b(CGM); |
1825 | auto ivarListBuilder = b.beginStruct(); |
1826 | |
1827 | ivarListBuilder.addInt(IntTy, ivar_count); |
1828 | |
1829 | llvm::StructType *ObjCIvarTy = llvm::StructType::get( |
1830 | PtrToInt8Ty, |
1831 | PtrToInt8Ty, |
1832 | PtrToInt8Ty, |
1833 | Int32Ty, |
1834 | Int32Ty); |
1835 | ivarListBuilder.addInt(SizeTy, td.getTypeSizeInBits(ObjCIvarTy) / |
1836 | CGM.getContext().getCharWidth()); |
1837 | |
1838 | auto ivarArrayBuilder = ivarListBuilder.beginArray(); |
1839 | for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD; |
| 8 | | Loop condition is false. Execution continues on line 1887 | |
|
1840 | IVD = IVD->getNextIvar()) { |
1841 | auto ivarTy = IVD->getType(); |
1842 | auto ivarBuilder = ivarArrayBuilder.beginStruct(); |
1843 | |
1844 | ivarBuilder.add(MakeConstantString(IVD->getNameAsString())); |
1845 | |
1846 | std::string TypeStr; |
1847 | |
1848 | Context.getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, ivarTy, TypeStr, true); |
1849 | ivarBuilder.add(MakeConstantString(TypeStr)); |
1850 | |
1851 | uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD); |
1852 | uint64_t Offset = BaseOffset - superInstanceSize; |
1853 | llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset); |
1854 | std::string OffsetName = GetIVarOffsetVariableName(classDecl, IVD); |
1855 | llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName); |
1856 | if (OffsetVar) |
1857 | OffsetVar->setInitializer(OffsetValue); |
1858 | else |
1859 | OffsetVar = new llvm::GlobalVariable(TheModule, IntTy, |
1860 | false, llvm::GlobalValue::ExternalLinkage, |
1861 | OffsetValue, OffsetName); |
1862 | auto ivarVisibility = |
1863 | (IVD->getAccessControl() == ObjCIvarDecl::Private || |
1864 | IVD->getAccessControl() == ObjCIvarDecl::Package || |
1865 | classDecl->getVisibility() == HiddenVisibility) ? |
1866 | llvm::GlobalValue::HiddenVisibility : |
1867 | llvm::GlobalValue::DefaultVisibility; |
1868 | OffsetVar->setVisibility(ivarVisibility); |
1869 | ivarBuilder.add(OffsetVar); |
1870 | |
1871 | ivarBuilder.addInt(Int32Ty, |
1872 | CGM.getContext().getTypeSizeInChars(ivarTy).getQuantity()); |
1873 | |
1874 | unsigned align = |
1875 | llvm::Log2_32(Context.getTypeAlignInChars(ivarTy).getQuantity()); |
1876 | |
1877 | assert(align < 64); |
1878 | |
1879 | |
1880 | |
1881 | |
1882 | ivarBuilder.addInt(Int32Ty, |
1883 | (align << 3) | (1<<2) | |
1884 | FlagsForOwnership(ivarTy.getQualifiers().getObjCLifetime())); |
1885 | ivarBuilder.finishAndAddTo(ivarArrayBuilder); |
1886 | } |
1887 | ivarArrayBuilder.finishAndAddTo(ivarListBuilder); |
1888 | auto ivarList = ivarListBuilder.finishAndCreateGlobal(".objc_ivar_list", |
1889 | CGM.getPointerAlign(), false, |
1890 | llvm::GlobalValue::PrivateLinkage); |
1891 | classFields.add(ivarList); |
1892 | } |
1893 | |
1894 | SmallVector<const ObjCMethodDecl*, 16> InstanceMethods; |
1895 | InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(), |
1896 | OID->instmeth_end()); |
1897 | for (auto *propImpl : OID->property_impls()) |
1898 | if (propImpl->getPropertyImplementation() == |
1899 | ObjCPropertyImplDecl::Synthesize) { |
1900 | auto addIfExists = [&](const ObjCMethodDecl *OMD) { |
1901 | if (OMD && OMD->hasBody()) |
1902 | InstanceMethods.push_back(OMD); |
1903 | }; |
1904 | addIfExists(propImpl->getGetterMethodDecl()); |
1905 | addIfExists(propImpl->getSetterMethodDecl()); |
1906 | } |
1907 | |
1908 | if (InstanceMethods.size() == 0) |
| 9 | | Assuming the condition is false | |
|
| |
1909 | classFields.addNullPointer(PtrTy); |
1910 | else |
1911 | classFields.addBitCast( |
1912 | GenerateMethodList(className, "", InstanceMethods, false), |
1913 | PtrTy); |
1914 | |
1915 | classFields.addNullPointer(PtrTy); |
1916 | |
1917 | classFields.addNullPointer(PtrTy); |
1918 | |
1919 | classFields.addNullPointer(PtrTy); |
1920 | |
1921 | classFields.addNullPointer(PtrTy); |
1922 | |
1923 | classFields.addNullPointer(PtrTy); |
1924 | |
1925 | auto RuntimeProtocols = GetRuntimeProtocolList(classDecl->protocol_begin(), |
1926 | classDecl->protocol_end()); |
1927 | SmallVector<llvm::Constant *, 16> Protocols; |
1928 | for (const auto *I : RuntimeProtocols) |
1929 | Protocols.push_back( |
1930 | llvm::ConstantExpr::getBitCast(GenerateProtocolRef(I), |
1931 | ProtocolPtrTy)); |
1932 | if (Protocols.empty()) |
| |
1933 | classFields.addNullPointer(PtrTy); |
1934 | else |
1935 | classFields.add(GenerateProtocolList(Protocols)); |
1936 | |
1937 | classFields.addNullPointer(PtrTy); |
1938 | |
1939 | classFields.addInt(LongTy, 0); |
1940 | |
1941 | classFields.add(GeneratePropertyList(OID, classDecl)); |
1942 | |
1943 | llvm::GlobalVariable *classStruct = |
1944 | classFields.finishAndCreateGlobal(SymbolForClass(className), |
1945 | CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage); |
1946 | |
1947 | auto *classRefSymbol = GetClassVar(className); |
| 12 | | Calling 'CGObjCGNUstep2::GetClassVar' | |
|
1948 | classRefSymbol->setSection(sectionName<ClassReferenceSection>()); |
1949 | classRefSymbol->setInitializer(llvm::ConstantExpr::getBitCast(classStruct, IdTy)); |
1950 | |
1951 | if (IsCOFF) { |
1952 | |
1953 | if (OID->getClassInterface()->hasAttr<DLLExportAttr>()) { |
1954 | classStruct->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); |
1955 | cast<llvm::GlobalValue>(classRefSymbol)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); |
1956 | } |
1957 | |
1958 | if (SuperClass) { |
1959 | std::pair<llvm::GlobalVariable*, int> v{classStruct, 1}; |
1960 | EarlyInitList.emplace_back(std::string(SuperClass->getName()), |
1961 | std::move(v)); |
1962 | } |
1963 | |
1964 | } |
1965 | |
1966 | |
1967 | |
1968 | |
1969 | if (ClassPtrAlias) { |
1970 | ClassPtrAlias->replaceAllUsesWith( |
1971 | llvm::ConstantExpr::getBitCast(classStruct, IdTy)); |
1972 | ClassPtrAlias->eraseFromParent(); |
1973 | ClassPtrAlias = nullptr; |
1974 | } |
1975 | if (auto Placeholder = |
1976 | TheModule.getNamedGlobal(SymbolForClass(className))) |
1977 | if (Placeholder != classStruct) { |
1978 | Placeholder->replaceAllUsesWith( |
1979 | llvm::ConstantExpr::getBitCast(classStruct, Placeholder->getType())); |
1980 | Placeholder->eraseFromParent(); |
1981 | classStruct->setName(SymbolForClass(className)); |
1982 | } |
1983 | if (MetaClassPtrAlias) { |
1984 | MetaClassPtrAlias->replaceAllUsesWith( |
1985 | llvm::ConstantExpr::getBitCast(metaclass, IdTy)); |
1986 | MetaClassPtrAlias->eraseFromParent(); |
1987 | MetaClassPtrAlias = nullptr; |
1988 | } |
1989 | assert(classStruct->getName() == SymbolForClass(className)); |
1990 | |
1991 | auto classInitRef = new llvm::GlobalVariable(TheModule, |
1992 | classStruct->getType(), false, llvm::GlobalValue::ExternalLinkage, |
1993 | classStruct, ManglePublicSymbol("OBJC_INIT_CLASS_") + className); |
1994 | classInitRef->setSection(sectionName<ClassSection>()); |
1995 | CGM.addUsedGlobal(classInitRef); |
1996 | |
1997 | EmittedClass = true; |
1998 | } |
1999 | public: |
2000 | CGObjCGNUstep2(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 10, 4, 2) { |
2001 | MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy, |
2002 | PtrToObjCSuperTy, SelectorTy); |
2003 | |
2004 | |
2005 | |
2006 | |
2007 | |
2008 | |
2009 | |
2010 | |
2011 | PropertyMetadataTy = |
2012 | llvm::StructType::get(CGM.getLLVMContext(), |
2013 | { PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty }); |
2014 | } |
2015 | |
2016 | }; |
2017 | |
2018 | const char *const CGObjCGNUstep2::SectionsBaseNames[8] = |
2019 | { |
2020 | "__objc_selectors", |
2021 | "__objc_classes", |
2022 | "__objc_class_refs", |
2023 | "__objc_cats", |
2024 | "__objc_protocols", |
2025 | "__objc_protocol_refs", |
2026 | "__objc_class_aliases", |
2027 | "__objc_constant_string" |
2028 | }; |
2029 | |
2030 | const char *const CGObjCGNUstep2::PECOFFSectionsBaseNames[8] = |
2031 | { |
2032 | ".objcrt$SEL", |
2033 | ".objcrt$CLS", |
2034 | ".objcrt$CLR", |
2035 | ".objcrt$CAT", |
2036 | ".objcrt$PCL", |
2037 | ".objcrt$PCR", |
2038 | ".objcrt$CAL", |
2039 | ".objcrt$STR" |
2040 | }; |
2041 | |
2042 | |
2043 | class CGObjCObjFW: public CGObjCGNU { |
2044 | protected: |
2045 | |
2046 | |
2047 | LazyRuntimeFunction MsgLookupFn; |
2048 | |
2049 | |
2050 | LazyRuntimeFunction MsgLookupFnSRet; |
2051 | |
2052 | |
2053 | |
2054 | LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet; |
2055 | |
2056 | llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, |
2057 | llvm::Value *cmd, llvm::MDNode *node, |
2058 | MessageSendInfo &MSI) override { |
2059 | CGBuilderTy &Builder = CGF.Builder; |
2060 | llvm::Value *args[] = { |
2061 | EnforceType(Builder, Receiver, IdTy), |
2062 | EnforceType(Builder, cmd, SelectorTy) }; |
2063 | |
2064 | llvm::CallBase *imp; |
2065 | if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) |
2066 | imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFnSRet, args); |
2067 | else |
2068 | imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args); |
2069 | |
2070 | imp->setMetadata(msgSendMDKind, node); |
2071 | return imp; |
2072 | } |
2073 | |
2074 | llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper, |
2075 | llvm::Value *cmd, MessageSendInfo &MSI) override { |
2076 | CGBuilderTy &Builder = CGF.Builder; |
2077 | llvm::Value *lookupArgs[] = { |
2078 | EnforceType(Builder, ObjCSuper.getPointer(), PtrToObjCSuperTy), cmd, |
2079 | }; |
2080 | |
2081 | if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) |
2082 | return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFnSRet, lookupArgs); |
2083 | else |
2084 | return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs); |
2085 | } |
2086 | |
2087 | llvm::Value *GetClassNamed(CodeGenFunction &CGF, const std::string &Name, |
2088 | bool isWeak) override { |
2089 | if (isWeak) |
2090 | return CGObjCGNU::GetClassNamed(CGF, Name, isWeak); |
2091 | |
2092 | EmitClassRef(Name); |
2093 | std::string SymbolName = "_OBJC_CLASS_" + Name; |
2094 | llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(SymbolName); |
2095 | if (!ClassSymbol) |
2096 | ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false, |
2097 | llvm::GlobalValue::ExternalLinkage, |
2098 | nullptr, SymbolName); |
2099 | return ClassSymbol; |
2100 | } |
2101 | |
2102 | public: |
2103 | CGObjCObjFW(CodeGenModule &Mod): CGObjCGNU(Mod, 9, 3) { |
2104 | |
2105 | MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy); |
2106 | MsgLookupFnSRet.init(&CGM, "objc_msg_lookup_stret", IMPTy, IdTy, |
2107 | SelectorTy); |
2108 | |
2109 | MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy, |
2110 | PtrToObjCSuperTy, SelectorTy); |
2111 | MsgLookupSuperFnSRet.init(&CGM, "objc_msg_lookup_super_stret", IMPTy, |
2112 | PtrToObjCSuperTy, SelectorTy); |
2113 | } |
2114 | }; |
2115 | } |
2116 | |
2117 | |
2118 | |
2119 | |
2120 | void CGObjCGNU::EmitClassRef(const std::string &className) { |
2121 | std::string symbolRef = "__objc_class_ref_" + className; |
2122 | |
2123 | if (TheModule.getGlobalVariable(symbolRef)) |
2124 | return; |
2125 | std::string symbolName = "__objc_class_name_" + className; |
2126 | llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName); |
2127 | if (!ClassSymbol) { |
2128 | ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false, |
2129 | llvm::GlobalValue::ExternalLinkage, |
2130 | nullptr, symbolName); |
2131 | } |
2132 | new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true, |
2133 | llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef); |
2134 | } |
2135 | |
2136 | CGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion, |
2137 | unsigned protocolClassVersion, unsigned classABI) |
2138 | : CGObjCRuntime(cgm), TheModule(CGM.getModule()), |
2139 | VMContext(cgm.getLLVMContext()), ClassPtrAlias(nullptr), |
2140 | MetaClassPtrAlias(nullptr), RuntimeVersion(runtimeABIVersion), |
2141 | ProtocolVersion(protocolClassVersion), ClassABIVersion(classABI) { |
2142 | |
2143 | msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend"); |
2144 | usesSEHExceptions = |
2145 | cgm.getContext().getTargetInfo().getTriple().isWindowsMSVCEnvironment(); |
2146 | |
2147 | CodeGenTypes &Types = CGM.getTypes(); |
2148 | IntTy = cast<llvm::IntegerType>( |
2149 | Types.ConvertType(CGM.getContext().IntTy)); |
2150 | LongTy = cast<llvm::IntegerType>( |
2151 | Types.ConvertType(CGM.getContext().LongTy)); |
2152 | SizeTy = cast<llvm::IntegerType>( |
2153 | Types.ConvertType(CGM.getContext().getSizeType())); |
2154 | PtrDiffTy = cast<llvm::IntegerType>( |
2155 | Types.ConvertType(CGM.getContext().getPointerDiffType())); |
2156 | BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy); |
2157 | |
2158 | Int8Ty = llvm::Type::getInt8Ty(VMContext); |
2159 | |
2160 | PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty); |
2161 | ProtocolPtrTy = llvm::PointerType::getUnqual( |
2162 | Types.ConvertType(CGM.getContext().getObjCProtoType())); |
2163 | |
2164 | Zeros[0] = llvm::ConstantInt::get(LongTy, 0); |
2165 | Zeros[1] = Zeros[0]; |
2166 | NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty); |
2167 | |
2168 | QualType selTy = CGM.getContext().getObjCSelType(); |
2169 | if (QualType() == selTy) { |
2170 | SelectorTy = PtrToInt8Ty; |
2171 | } else { |
2172 | SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy)); |
2173 | } |
2174 | |
2175 | PtrToIntTy = llvm::PointerType::getUnqual(IntTy); |
2176 | PtrTy = PtrToInt8Ty; |
2177 | |
2178 | Int32Ty = llvm::Type::getInt32Ty(VMContext); |
2179 | Int64Ty = llvm::Type::getInt64Ty(VMContext); |
2180 | |
2181 | IntPtrTy = |
2182 | CGM.getDataLayout().getPointerSizeInBits() == 32 ? Int32Ty : Int64Ty; |
2183 | |
2184 | |
2185 | QualType UnqualIdTy = CGM.getContext().getObjCIdType(); |
2186 | ASTIdTy = CanQualType(); |
2187 | if (UnqualIdTy != QualType()) { |
2188 | ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy); |
2189 | IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy)); |
2190 | } else { |
2191 | IdTy = PtrToInt8Ty; |
2192 | } |
2193 | PtrToIdTy = llvm::PointerType::getUnqual(IdTy); |
2194 | ProtocolTy = llvm::StructType::get(IdTy, |
2195 | PtrToInt8Ty, |
2196 | PtrToInt8Ty, |
2197 | PtrToInt8Ty, |
2198 | PtrToInt8Ty, |
2199 | PtrToInt8Ty, |
2200 | PtrToInt8Ty, |
2201 | PtrToInt8Ty, |
2202 | PtrToInt8Ty); |
2203 | |
2204 | |
2205 | |
2206 | |
2207 | |
2208 | |
2209 | |
2210 | |
2211 | |
2212 | |
2213 | |
2214 | |
2215 | |
2216 | PropertyMetadataTy = llvm::StructType::get(CGM.getLLVMContext(), { |
2217 | PtrToInt8Ty, Int8Ty, Int8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty, |
2218 | PtrToInt8Ty, PtrToInt8Ty }); |
2219 | |
2220 | ObjCSuperTy = llvm::StructType::get(IdTy, IdTy); |
2221 | PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy); |
2222 | |
2223 | llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); |
2224 | |
2225 | |
2226 | ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy); |
2227 | ExceptionReThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy); |
2228 | |
2229 | SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy); |
2230 | |
2231 | SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy); |
2232 | |
2233 | |
2234 | EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy, IdTy); |
2235 | |
2236 | |
2237 | GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy, |
2238 | PtrDiffTy, BoolTy); |
2239 | |
2240 | SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy, |
2241 | PtrDiffTy, IdTy, BoolTy, BoolTy); |
2242 | |
2243 | GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy, |
2244 | PtrDiffTy, BoolTy, BoolTy); |
2245 | |
2246 | SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy, |
2247 | PtrDiffTy, BoolTy, BoolTy); |
2248 | |
2249 | |
2250 | llvm::Type *IMPArgs[] = { IdTy, SelectorTy }; |
2251 | IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs, |
2252 | true)); |
2253 | |
2254 | const LangOptions &Opts = CGM.getLangOpts(); |
2255 | if ((Opts.getGC() != LangOptions::NonGC) || Opts.ObjCAutoRefCount) |
2256 | RuntimeVersion = 10; |
2257 | |
2258 | |
2259 | if (Opts.getGC() != LangOptions::NonGC) { |
2260 | |
2261 | |
2262 | |
2263 | |
2264 | RetainSel = GetNullarySelector("retain", CGM.getContext()); |
2265 | ReleaseSel = GetNullarySelector("release", CGM.getContext()); |
2266 | AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext()); |
2267 | |
2268 | |
2269 | |
2270 | |
2271 | IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy); |
2272 | |
2273 | StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy, |
2274 | PtrToIdTy); |
2275 | |
2276 | GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy); |
2277 | |
2278 | WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy); |
2279 | |
2280 | WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy); |
2281 | |
2282 | MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy, |
2283 | SizeTy); |
2284 | } |
2285 | } |
2286 | |
2287 | llvm::Value *CGObjCGNU::GetClassNamed(CodeGenFunction &CGF, |
2288 | const std::string &Name, bool isWeak) { |
2289 | llvm::Constant *ClassName = MakeConstantString(Name); |
2290 | |
2291 | |
2292 | |
2293 | |
2294 | |
2295 | |
2296 | |
2297 | if (!isWeak) |
2298 | EmitClassRef(Name); |
2299 | |
2300 | llvm::FunctionCallee ClassLookupFn = CGM.CreateRuntimeFunction( |
2301 | llvm::FunctionType::get(IdTy, PtrToInt8Ty, true), "objc_lookup_class"); |
2302 | return CGF.EmitNounwindRuntimeCall(ClassLookupFn, ClassName); |
2303 | } |
2304 | |
2305 | |
2306 | |
2307 | llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF, |
2308 | const ObjCInterfaceDecl *OID) { |
2309 | auto *Value = |
2310 | GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported()); |
2311 | if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) |
2312 | CGM.setGVProperties(ClassSymbol, OID); |
2313 | return Value; |
2314 | } |
2315 | |
2316 | llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) { |
2317 | auto *Value = GetClassNamed(CGF, "NSAutoreleasePool", false); |
2318 | if (CGM.getTriple().isOSBinFormatCOFF()) { |
2319 | if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) { |
2320 | IdentifierInfo &II = CGF.CGM.getContext().Idents.get("NSAutoreleasePool"); |
2321 | TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); |
2322 | DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); |
2323 | |
2324 | const VarDecl *VD = nullptr; |
2325 | for (const auto *Result : DC->lookup(&II)) |
2326 | if ((VD = dyn_cast<VarDecl>(Result))) |
2327 | break; |
2328 | |
2329 | CGM.setGVProperties(ClassSymbol, VD); |
2330 | } |
2331 | } |
2332 | return Value; |
2333 | } |
2334 | |
2335 | llvm::Value *CGObjCGNU::GetTypedSelector(CodeGenFunction &CGF, Selector Sel, |
2336 | const std::string &TypeEncoding) { |
2337 | SmallVectorImpl<TypedSelector> &Types = SelectorTable[Sel]; |
2338 | llvm::GlobalAlias *SelValue = nullptr; |
2339 | |
2340 | for (SmallVectorImpl<TypedSelector>::iterator i = Types.begin(), |
2341 | e = Types.end() ; i!=e ; i++) { |
2342 | if (i->first == TypeEncoding) { |
2343 | SelValue = i->second; |
2344 | break; |
2345 | } |
2346 | } |
2347 | if (!SelValue) { |
2348 | SelValue = llvm::GlobalAlias::create( |
2349 | SelectorTy->getElementType(), 0, llvm::GlobalValue::PrivateLinkage, |
2350 | ".objc_selector_" + Sel.getAsString(), &TheModule); |
2351 | Types.emplace_back(TypeEncoding, SelValue); |
2352 | } |
2353 | |
2354 | return SelValue; |
2355 | } |
2356 | |
2357 | Address CGObjCGNU::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) { |
2358 | llvm::Value *SelValue = GetSelector(CGF, Sel); |
2359 | |
2360 | |
2361 | |
2362 | Address tmp = CGF.CreateTempAlloca(SelValue->getType(), |
2363 | CGF.getPointerAlign()); |
2364 | CGF.Builder.CreateStore(SelValue, tmp); |
2365 | return tmp; |
2366 | } |
2367 | |
2368 | llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel) { |
2369 | return GetTypedSelector(CGF, Sel, std::string()); |
2370 | } |
2371 | |
2372 | llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, |
2373 | const ObjCMethodDecl *Method) { |
2374 | std::string SelTypes = CGM.getContext().getObjCEncodingForMethodDecl(Method); |
2375 | return GetTypedSelector(CGF, Method->getSelector(), SelTypes); |
2376 | } |
2377 | |
2378 | llvm::Constant *CGObjCGNU::GetEHType(QualType T) { |
2379 | if (T->isObjCIdType() || T->isObjCQualifiedIdType()) { |
2380 | |
2381 | |
2382 | |
2383 | |
2384 | if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { |
2385 | return MakeConstantString("@id"); |
2386 | } else { |
2387 | return nullptr; |
2388 | } |
2389 | } |
2390 | |
2391 | |
2392 | const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>(); |
2393 | assert(OPT && "Invalid @catch type."); |
2394 | const ObjCInterfaceDecl *IDecl = OPT->getObjectType()->getInterface(); |
2395 | assert(IDecl && "Invalid @catch type."); |
2396 | return MakeConstantString(IDecl->getIdentifier()->getName()); |
2397 | } |
2398 | |
2399 | llvm::Constant *CGObjCGNUstep::GetEHType(QualType T) { |
2400 | if (usesSEHExceptions) |
2401 | return CGM.getCXXABI().getAddrOfRTTIDescriptor(T); |
2402 | |
2403 | if (!CGM.getLangOpts().CPlusPlus) |
2404 | return CGObjCGNU::GetEHType(T); |
2405 | |
2406 | |
2407 | |
2408 | |
2409 | |
2410 | if (T->isObjCIdType() || |
2411 | T->isObjCQualifiedIdType()) { |
2412 | llvm::Constant *IDEHType = |
2413 | CGM.getModule().getGlobalVariable("__objc_id_type_info"); |
2414 | if (!IDEHType) |
2415 | IDEHType = |
2416 | new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty, |
2417 | false, |
2418 | llvm::GlobalValue::ExternalLinkage, |
2419 | nullptr, "__objc_id_type_info"); |
2420 | return llvm::ConstantExpr::getBitCast(IDEHType, PtrToInt8Ty); |
2421 | } |
2422 | |
2423 | const ObjCObjectPointerType *PT = |
2424 | T->getAs<ObjCObjectPointerType>(); |
2425 | assert(PT && "Invalid @catch type."); |
2426 | const ObjCInterfaceType *IT = PT->getInterfaceType(); |
2427 | assert(IT && "Invalid @catch type."); |
2428 | std::string className = |
2429 | std::string(IT->getDecl()->getIdentifier()->getName()); |
2430 | |
2431 | std::string typeinfoName = "__objc_eh_typeinfo_" + className; |
2432 | |
2433 | |
2434 | llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName); |
2435 | if (typeinfo) |
2436 | return llvm::ConstantExpr::getBitCast(typeinfo, PtrToInt8Ty); |
2437 | |
2438 | |
2439 | |
2440 | |
2441 | |
2442 | |
2443 | const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE"; |
2444 | auto *Vtable = TheModule.getGlobalVariable(vtableName); |
2445 | if (!Vtable) { |
2446 | Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true, |
2447 | llvm::GlobalValue::ExternalLinkage, |
2448 | nullptr, vtableName); |
2449 | } |
2450 | llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2); |
2451 | auto *BVtable = llvm::ConstantExpr::getBitCast( |
2452 | llvm::ConstantExpr::getGetElementPtr(Vtable->getValueType(), Vtable, Two), |
2453 | PtrToInt8Ty); |
2454 | |
2455 | llvm::Constant *typeName = |
2456 | ExportUniqueString(className, "__objc_eh_typename_"); |
2457 | |
2458 | ConstantInitBuilder builder(CGM); |
2459 | auto fields = builder.beginStruct(); |
2460 | fields.add(BVtable); |
2461 | fields.add(typeName); |
2462 | llvm::Constant *TI = |
2463 | fields.finishAndCreateGlobal("__objc_eh_typeinfo_" + className, |
2464 | CGM.getPointerAlign(), |
2465 | false, |
2466 | llvm::GlobalValue::LinkOnceODRLinkage); |
2467 | return llvm::ConstantExpr::getBitCast(TI, PtrToInt8Ty); |
2468 | } |
2469 | |
2470 | |
2471 | ConstantAddress CGObjCGNU::GenerateConstantString(const StringLiteral *SL) { |
2472 | |
2473 | std::string Str = SL->getString().str(); |
2474 | CharUnits Align = CGM.getPointerAlign(); |
2475 | |
2476 | |
2477 | llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str); |
2478 | if (old != ObjCStrings.end()) |
2479 | return ConstantAddress(old->getValue(), Align); |
2480 | |
2481 | StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass; |
2482 | |
2483 | if (StringClass.empty()) StringClass = "NSConstantString"; |
2484 | |
2485 | std::string Sym = "_OBJC_CLASS_"; |
2486 | Sym += StringClass; |
2487 | |
2488 | llvm::Constant *isa = TheModule.getNamedGlobal(Sym); |
2489 | |
2490 | if (!isa) |
2491 | isa = new llvm::GlobalVariable(TheModule, IdTy, false, |
2492 | llvm::GlobalValue::ExternalWeakLinkage, nullptr, Sym); |
2493 | else if (isa->getType() != PtrToIdTy) |
2494 | isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy); |
2495 | |
2496 | ConstantInitBuilder Builder(CGM); |
2497 | auto Fields = Builder.beginStruct(); |
2498 | Fields.add(isa); |
2499 | Fields.add(MakeConstantString(Str)); |
2500 | Fields.addInt(IntTy, Str.size()); |
2501 | llvm::Constant *ObjCStr = |
2502 | Fields.finishAndCreateGlobal(".objc_str", Align); |
2503 | ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty); |
2504 | ObjCStrings[Str] = ObjCStr; |
2505 | ConstantStrings.push_back(ObjCStr); |
2506 | return ConstantAddress(ObjCStr, Align); |
2507 | } |
2508 | |
2509 | |
2510 | |
2511 | |
2512 | RValue |
2513 | CGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF, |
2514 | ReturnValueSlot Return, |
2515 | QualType ResultType, |
2516 | Selector Sel, |
2517 | const ObjCInterfaceDecl *Class, |
2518 | bool isCategoryImpl, |
2519 | llvm::Value *Receiver, |
2520 | bool IsClassMessage, |
2521 | const CallArgList &CallArgs, |
2522 | const ObjCMethodDecl *Method) { |
2523 | CGBuilderTy &Builder = CGF.Builder; |
2524 | if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) { |
2525 | if (Sel == RetainSel || Sel == AutoreleaseSel) { |
2526 | return RValue::get(EnforceType(Builder, Receiver, |
2527 | CGM.getTypes().ConvertType(ResultType))); |
2528 | } |
2529 | if (Sel == ReleaseSel) { |
2530 | return RValue::get(nullptr); |
2531 | } |
2532 | } |
2533 | |
2534 | llvm::Value *cmd = GetSelector(CGF, Sel); |
2535 | CallArgList ActualArgs; |
2536 | |
2537 | ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy); |
2538 | ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType()); |
2539 | ActualArgs.addFrom(CallArgs); |
2540 | |
2541 | MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs); |
2542 | |
2543 | llvm::Value *ReceiverClass = nullptr; |
2544 | bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2); |
2545 | if (isV2ABI) { |
2546 | ReceiverClass = GetClassNamed(CGF, |
2547 | Class->getSuperClass()->getNameAsString(), false); |
2548 | if (IsClassMessage) { |
2549 | |
2550 | ReceiverClass = Builder.CreateBitCast(ReceiverClass, |
2551 | llvm::PointerType::getUnqual(IdTy)); |
2552 | ReceiverClass = |
2553 | Builder.CreateAlignedLoad(IdTy, ReceiverClass, CGF.getPointerAlign()); |
2554 | } |
2555 | ReceiverClass = EnforceType(Builder, ReceiverClass, IdTy); |
2556 | } else { |
2557 | if (isCategoryImpl) { |
2558 | llvm::FunctionCallee classLookupFunction = nullptr; |
2559 | if (IsClassMessage) { |
2560 | classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get( |
2561 | IdTy, PtrTy, true), "objc_get_meta_class"); |
2562 | } else { |
2563 | classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get( |
2564 | IdTy, PtrTy, true), "objc_get_class"); |
2565 | } |
2566 | ReceiverClass = Builder.CreateCall(classLookupFunction, |
2567 | MakeConstantString(Class->getNameAsString())); |
2568 | } else { |
2569 | |
2570 | |
2571 | |
2572 | |
2573 | |
2574 | if (IsClassMessage) { |
2575 | if (!MetaClassPtrAlias) { |
2576 | MetaClassPtrAlias = llvm::GlobalAlias::create( |
2577 | IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage, |
2578 | ".objc_metaclass_ref" + Class->getNameAsString(), &TheModule); |
2579 | } |
2580 | ReceiverClass = MetaClassPtrAlias; |
2581 | } else { |
2582 | if (!ClassPtrAlias) { |
2583 | ClassPtrAlias = llvm::GlobalAlias::create( |
2584 | IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage, |
2585 | ".objc_class_ref" + Class->getNameAsString(), &TheModule); |
2586 | } |
2587 | ReceiverClass = ClassPtrAlias; |
2588 | } |
2589 | } |
2590 | |
2591 | llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy); |
2592 | ReceiverClass = Builder.CreateBitCast(ReceiverClass, |
2593 | llvm::PointerType::getUnqual(CastTy)); |
2594 | |
2595 | ReceiverClass = Builder.CreateStructGEP(CastTy, ReceiverClass, 1); |
2596 | |
2597 | ReceiverClass = |
2598 | Builder.CreateAlignedLoad(IdTy, ReceiverClass, CGF.getPointerAlign()); |
2599 | } |
2600 | |
2601 | llvm::StructType *ObjCSuperTy = |
2602 | llvm::StructType::get(Receiver->getType(), IdTy); |
2603 | |
2604 | Address ObjCSuper = CGF.CreateTempAlloca(ObjCSuperTy, |
2605 | CGF.getPointerAlign()); |
2606 | |
2607 | Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0)); |
2608 | Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1)); |
2609 | |
2610 | ObjCSuper = EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy); |
2611 | |
2612 | |
2613 | llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd, MSI); |
2614 | imp = EnforceType(Builder, imp, MSI.MessengerType); |
2615 | |
2616 | llvm::Metadata *impMD[] = { |
2617 | llvm::MDString::get(VMContext, Sel.getAsString()), |
2618 | llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()), |
2619 | llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( |
2620 | llvm::Type::getInt1Ty(VMContext), IsClassMessage))}; |
2621 | llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD); |
2622 | |
2623 | CGCallee callee(CGCalleeInfo(), imp); |
2624 | |
2625 | llvm::CallBase *call; |
2626 | RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call); |
2627 | call->setMetadata(msgSendMDKind, node); |
2628 | return msgRet; |
2629 | } |
2630 | |
2631 | |
2632 | RValue |
2633 | CGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF, |
2634 | ReturnValueSlot Return, |
2635 | QualType ResultType, |
2636 | Selector Sel, |
2637 | llvm::Value *Receiver, |
2638 | const CallArgList &CallArgs, |
2639 | const ObjCInterfaceDecl *Class, |
2640 | const ObjCMethodDecl *Method) { |
2641 | CGBuilderTy &Builder = CGF.Builder; |
2642 | |
2643 | |
2644 | if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) { |
2645 | if (Sel == RetainSel || Sel == AutoreleaseSel) { |
2646 | return RValue::get(EnforceType(Builder, Receiver, |
2647 | CGM.getTypes().ConvertType(ResultType))); |
2648 | } |
2649 | if (Sel == ReleaseSel) { |
2650 | return RValue::get(nullptr); |
2651 | } |
2652 | } |
2653 | |
2654 | |
2655 | |
2656 | |
2657 | |
2658 | |
2659 | |
2660 | |
2661 | |
2662 | |
2663 | |
2664 | |
2665 | bool isPointerSizedReturn = (ResultType->isAnyPointerType() || |
2666 | ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType()); |
2667 | |
2668 | llvm::BasicBlock *startBB = nullptr; |
2669 | llvm::BasicBlock *messageBB = nullptr; |
2670 | llvm::BasicBlock *continueBB = nullptr; |
2671 | |
2672 | if (!isPointerSizedReturn) { |
2673 | startBB = Builder.GetInsertBlock(); |
2674 | messageBB = CGF.createBasicBlock("msgSend"); |
2675 | continueBB = CGF.createBasicBlock("continue"); |
2676 | |
2677 | llvm::Value *isNil = Builder.CreateICmpEQ(Receiver, |
2678 | llvm::Constant::getNullValue(Receiver->getType())); |
2679 | Builder.CreateCondBr(isNil, continueBB, messageBB); |
2680 | CGF.EmitBlock(messageBB); |
2681 | } |
2682 | |
2683 | IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy)); |
2684 | llvm::Value *cmd; |
2685 | if (Method) |
2686 | cmd = GetSelector(CGF, Method); |
2687 | else |
2688 | cmd = GetSelector(CGF, Sel); |
2689 | cmd = EnforceType(Builder, cmd, SelectorTy); |
2690 | Receiver = EnforceType(Builder, Receiver, IdTy); |
2691 | |
2692 | llvm::Metadata *impMD[] = { |
2693 | llvm::MDString::get(VMContext, Sel.getAsString()), |
2694 | llvm::MDString::get(VMContext, Class ? Class->getNameAsString() : ""), |
2695 | llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( |
2696 | llvm::Type::getInt1Ty(VMContext), Class != nullptr))}; |
2697 | llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD); |
2698 | |
2699 | CallArgList ActualArgs; |
2700 | ActualArgs.add(RValue::get(Receiver), ASTIdTy); |
2701 | ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType()); |
2702 | ActualArgs.addFrom(CallArgs); |
2703 | |
2704 | MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs); |
2705 | |
2706 | |
2707 | llvm::Value *imp; |
2708 | |
2709 | |
2710 | |
2711 | |
2712 | switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) { |
2713 | case CodeGenOptions::Legacy: |
2714 | imp = LookupIMP(CGF, Receiver, cmd, node, MSI); |
2715 | break; |
2716 | case CodeGenOptions::Mixed: |
2717 | case CodeGenOptions::NonLegacy: |
2718 | if (CGM.ReturnTypeUsesFPRet(ResultType)) { |
2719 | imp = |
2720 | CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true), |
2721 | "objc_msgSend_fpret") |
2722 | .getCallee(); |
2723 | } else if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) { |
2724 | |
2725 | |
2726 | imp = |
2727 | CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true), |
2728 | "objc_msgSend_stret") |
2729 | .getCallee(); |
2730 | } else { |
2731 | imp = CGM.CreateRuntimeFunction( |
2732 | llvm::FunctionType::get(IdTy, IdTy, true), "objc_msgSend") |
2733 | .getCallee(); |
2734 | } |
2735 | } |
2736 | |
2737 | |
2738 | ActualArgs[0] = CallArg(RValue::get(Receiver), ASTIdTy); |
2739 | |
2740 | imp = EnforceType(Builder, imp, MSI.MessengerType); |
2741 | |
2742 | llvm::CallBase *call; |
2743 | CGCallee callee(CGCalleeInfo(), imp); |
2744 | RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call); |
2745 | call->setMetadata(msgSendMDKind, node); |
2746 | |
2747 | |
2748 | if (!isPointerSizedReturn) { |
2749 | messageBB = CGF.Builder.GetInsertBlock(); |
2750 | CGF.Builder.CreateBr(continueBB); |
2751 | CGF.EmitBlock(continueBB); |
2752 | if (msgRet.isScalar()) { |
2753 | llvm::Value *v = msgRet.getScalarVal(); |
2754 | llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2); |
2755 | phi->addIncoming(v, messageBB); |
2756 | phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB); |
2757 | msgRet = RValue::get(phi); |
2758 | } else if (msgRet.isAggregate()) { |
2759 | Address v = msgRet.getAggregateAddress(); |
2760 | llvm::PHINode *phi = Builder.CreatePHI(v.getType(), 2); |
2761 | llvm::Type *RetTy = v.getElementType(); |
2762 | Address NullVal = CGF.CreateTempAlloca(RetTy, v.getAlignment(), "null"); |
2763 | CGF.InitTempAlloca(NullVal, llvm::Constant::getNullValue(RetTy)); |
2764 | phi->addIncoming(v.getPointer(), messageBB); |
2765 | phi->addIncoming(NullVal.getPointer(), startBB); |
2766 | msgRet = RValue::getAggregate(Address(phi, v.getAlignment())); |
2767 | } else { |
2768 | std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal(); |
2769 | llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2); |
2770 | phi->addIncoming(v.first, messageBB); |
2771 | phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()), |
2772 | startBB); |
2773 | llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2); |
2774 | phi2->addIncoming(v.second, messageBB); |
2775 | phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()), |
2776 | startBB); |
2777 | msgRet = RValue::getComplex(phi, phi2); |
2778 | } |
2779 | } |
2780 | return msgRet; |
2781 | } |
2782 | |
2783 | |
2784 | |
2785 | llvm::Constant *CGObjCGNU:: |
2786 | GenerateMethodList(StringRef ClassName, |
2787 | StringRef CategoryName, |
2788 | ArrayRef<const ObjCMethodDecl*> Methods, |
2789 | bool isClassMethodList) { |
2790 | if (Methods.empty()) |
2791 | return NULLPtr; |
2792 | |
2793 | ConstantInitBuilder Builder(CGM); |
2794 | |
2795 | auto MethodList = Builder.beginStruct(); |
2796 | MethodList.addNullPointer(CGM.Int8PtrTy); |
2797 | MethodList.addInt(Int32Ty, Methods.size()); |
2798 | |
2799 | |
2800 | llvm::StructType *ObjCMethodTy = |
2801 | llvm::StructType::get(CGM.getLLVMContext(), { |
2802 | PtrToInt8Ty, |
2803 | PtrToInt8Ty, |
2804 | IMPTy |
2805 | }); |
2806 | bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2); |
2807 | if (isV2ABI) { |
2808 | |
2809 | llvm::DataLayout td(&TheModule); |
2810 | MethodList.addInt(SizeTy, td.getTypeSizeInBits(ObjCMethodTy) / |
2811 | CGM.getContext().getCharWidth()); |
2812 | ObjCMethodTy = |
2813 | llvm::StructType::get(CGM.getLLVMContext(), { |
2814 | IMPTy, |
2815 | PtrToInt8Ty, |
2816 | PtrToInt8Ty |
2817 | }); |
2818 | } else { |
2819 | ObjCMethodTy = |
2820 | llvm::StructType::get(CGM.getLLVMContext(), { |
2821 | PtrToInt8Ty, |
2822 | PtrToInt8Ty, |
2823 | IMPTy |
2824 | }); |
2825 | } |
2826 | auto MethodArray = MethodList.beginArray(); |
2827 | ASTContext &Context = CGM.getContext(); |
2828 | for (const auto *OMD : Methods) { |
2829 | llvm::Constant *FnPtr = |
2830 | TheModule.getFunction(getSymbolNameForMethod(OMD)); |
2831 | assert(FnPtr && "Can't generate metadata for method that doesn't exist"); |
2832 | auto Method = MethodArray.beginStruct(ObjCMethodTy); |
2833 | if (isV2ABI) { |
2834 | Method.addBitCast(FnPtr, IMPTy); |
2835 | Method.add(GetConstantSelector(OMD->getSelector(), |
2836 | Context.getObjCEncodingForMethodDecl(OMD))); |
2837 | Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD, true))); |
2838 | } else { |
2839 | Method.add(MakeConstantString(OMD->getSelector().getAsString())); |
2840 | Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD))); |
2841 | Method.addBitCast(FnPtr, IMPTy); |
2842 | } |
2843 | Method.finishAndAddTo(MethodArray); |
2844 | } |
2845 | MethodArray.finishAndAddTo(MethodList); |
2846 | |
2847 | |
2848 | return MethodList.finishAndCreateGlobal(".objc_method_list", |
2849 | CGM.getPointerAlign()); |
2850 | } |
2851 | |
2852 | |
2853 | llvm::Constant *CGObjCGNU:: |
2854 | GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames, |
2855 | ArrayRef<llvm::Constant *> IvarTypes, |
2856 | ArrayRef<llvm::Constant *> IvarOffsets, |
2857 | ArrayRef<llvm::Constant *> IvarAlign, |
2858 | ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) { |
2859 | if (IvarNames.empty()) |
2860 | return NULLPtr; |
2861 | |
2862 | ConstantInitBuilder Builder(CGM); |
2863 | |
2864 | |
2865 | auto IvarList = Builder.beginStruct(); |
2866 | IvarList.addInt(IntTy, (int)IvarNames.size()); |
2867 | |
2868 | |
2869 | llvm::StructType *ObjCIvarTy = |
2870 | llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy); |
2871 | |
2872 | |
2873 | auto Ivars = IvarList.beginArray(ObjCIvarTy); |
2874 | for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) { |
2875 | auto Ivar = Ivars.beginStruct(ObjCIvarTy); |
2876 | Ivar.add(IvarNames[i]); |
2877 | Ivar.add(IvarTypes[i]); |
2878 | Ivar.add(IvarOffsets[i]); |
2879 | Ivar.finishAndAddTo(Ivars); |
2880 | } |
2881 | Ivars.finishAndAddTo(IvarList); |
2882 | |
2883 | |
2884 | return IvarList.finishAndCreateGlobal(".objc_ivar_list", |
2885 | CGM.getPointerAlign()); |
2886 | } |
2887 | |
2888 | |
2889 | llvm::Constant *CGObjCGNU::GenerateClassStructure( |
2890 | llvm::Constant *MetaClass, |
2891 | llvm::Constant *SuperClass, |
2892 | unsigned info, |
2893 | const char *Name, |
2894 | llvm::Constant *Version, |
2895 | llvm::Constant *InstanceSize, |
2896 | llvm::Constant *IVars, |
2897 | llvm::Constant *Methods, |
2898 | llvm::Constant *Protocols, |
2899 | llvm::Constant *IvarOffsets, |
2900 | llvm::Constant *Properties, |
2901 | llvm::Constant *StrongIvarBitmap, |
2902 | llvm::Constant *WeakIvarBitmap, |
2903 | bool isMeta) { |
2904 | |
2905 | |
2906 | |
2907 | |
2908 | |
2909 | |
2910 | |
2911 | llvm::StructType *ClassTy = llvm::StructType::get( |
2912 | PtrToInt8Ty, |
2913 | PtrToInt8Ty, |
2914 | PtrToInt8Ty, |
2915 | LongTy, |
2916 | LongTy, |
2917 | LongTy, |
2918 | IVars->getType(), |
2919 | Methods->getType(), |
2920 | |
2921 | PtrTy, |
2922 | PtrTy, |
2923 | PtrTy, |
2924 | PtrTy, |
2925 | PtrTy, |
2926 | |
2927 | LongTy, |
2928 | IvarOffsets->getType(), |
2929 | Properties->getType(), |
2930 | IntPtrTy, |
2931 | IntPtrTy |
2932 | ); |
2933 | |
2934 | ConstantInitBuilder Builder(CGM); |
2935 | auto Elements = Builder.beginStruct(ClassTy); |
2936 | |
2937 | |
2938 | |
2939 | |
2940 | Elements.addBitCast(MetaClass, PtrToInt8Ty); |
2941 | |
2942 | Elements.add(SuperClass); |
2943 | |
2944 | Elements.add(MakeConstantString(Name, ".class_name")); |
2945 | |
2946 | Elements.addInt(LongTy, 0); |
2947 | |
2948 | Elements.addInt(LongTy, info); |
2949 | |
2950 | if (isMeta) { |
2951 | llvm::DataLayout td(&TheModule); |
2952 | Elements.addInt(LongTy, |
2953 | td.getTypeSizeInBits(ClassTy) / |
2954 | CGM.getContext().getCharWidth()); |
2955 | } else |
2956 | Elements.add(InstanceSize); |
2957 | |
2958 | Elements.add(IVars); |
2959 | |
2960 | Elements.add(Methods); |
2961 | |
2962 | |
2963 | Elements.add(NULLPtr); |
2964 | |
2965 | Elements.add(NULLPtr); |
2966 | |
2967 | Elements.add(NULLPtr); |
2968 | |
2969 | Elements.addBitCast(Protocols, PtrTy); |
2970 | |
2971 | Elements.add(NULLPtr); |
2972 | |
2973 | Elements.addInt(LongTy, ClassABIVersion); |
2974 | |
2975 | Elements.add(IvarOffsets); |
2976 | |
2977 | Elements.add(Properties); |
2978 | |
2979 | Elements.add(StrongIvarBitmap); |
2980 | |
2981 | Elements.add(WeakIvarBitmap); |
2982 | |
2983 | |
2984 | |
2985 | |
2986 | std::string ClassSym((isMeta ? "_OBJC_METACLASS_": "_OBJC_CLASS_") + |
2987 | std::string(Name)); |
2988 | llvm::GlobalVariable *ClassRef = TheModule.getNamedGlobal(ClassSym); |
2989 | llvm::Constant *Class = |
2990 | Elements.finishAndCreateGlobal(ClassSym, CGM.getPointerAlign(), false, |
2991 | llvm::GlobalValue::ExternalLinkage); |
2992 | if (ClassRef) { |
2993 | ClassRef->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(Class, |
2994 | ClassRef->getType())); |
2995 | ClassRef->removeFromParent(); |
2996 | Class->setName(ClassSym); |
2997 | } |
2998 | return Class; |
2999 | } |
3000 | |
3001 | llvm::Constant *CGObjCGNU:: |
3002 | GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) { |
3003 | |
3004 | llvm::StructType *ObjCMethodDescTy = |
3005 | llvm::StructType::get(CGM.getLLVMContext(), { PtrToInt8Ty, PtrToInt8Ty }); |
3006 | ASTContext &Context = CGM.getContext(); |
3007 | ConstantInitBuilder Builder(CGM); |
3008 | auto MethodList = Builder.beginStruct(); |
3009 | MethodList.addInt(IntTy, Methods.size()); |
3010 | auto MethodArray = MethodList.beginArray(ObjCMethodDescTy); |
3011 | for (auto *M : Methods) { |
3012 | auto Method = MethodArray.beginStruct(ObjCMethodDescTy); |
3013 | Method.add(MakeConstantString(M->getSelector().getAsString())); |
3014 | Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(M))); |
3015 | Method.finishAndAddTo(MethodArray); |
3016 | } |
3017 | MethodArray.finishAndAddTo(MethodList); |
3018 | return MethodList.finishAndCreateGlobal(".objc_method_list", |
3019 | CGM.getPointerAlign()); |
3020 | } |
3021 | |
3022 | |
3023 | llvm::Constant * |
3024 | CGObjCGNU::GenerateProtocolList(ArrayRef<std::string> Protocols) { |
3025 | |
3026 | ConstantInitBuilder Builder(CGM); |
3027 | auto ProtocolList = Builder.beginStruct(); |
3028 | ProtocolList.add(NULLPtr); |
3029 | ProtocolList.addInt(LongTy, Protocols.size()); |
3030 | |
3031 | auto Elements = ProtocolList.beginArray(PtrToInt8Ty); |
3032 | for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end(); |
3033 | iter != endIter ; iter++) { |
3034 | llvm::Constant *protocol = nullptr; |
3035 | llvm::StringMap<llvm::Constant*>::iterator value = |
3036 | ExistingProtocols.find(*iter); |
3037 | if (value == ExistingProtocols.end()) { |
3038 | protocol = GenerateEmptyProtocol(*iter); |
3039 | } else { |
3040 | protocol = value->getValue(); |
3041 | } |
3042 | Elements.addBitCast(protocol, PtrToInt8Ty); |
3043 | } |
3044 | Elements.finishAndAddTo(ProtocolList); |
3045 | return ProtocolList.finishAndCreateGlobal(".objc_protocol_list", |
3046 | CGM.getPointerAlign()); |
3047 | } |
3048 | |
3049 | llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF, |
3050 | const ObjCProtocolDecl *PD) { |
3051 | auto protocol = GenerateProtocolRef(PD); |
3052 | llvm::Type *T = |
3053 | CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType()); |
3054 | return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T)); |
3055 | } |
3056 | |
3057 | llvm::Constant *CGObjCGNU::GenerateProtocolRef(const ObjCProtocolDecl *PD) { |
3058 | llvm::Constant *&protocol = ExistingProtocols[PD->getNameAsString()]; |
3059 | if (!protocol) |
3060 | GenerateProtocol(PD); |
3061 | assert(protocol && "Unknown protocol"); |
3062 | return protocol; |
3063 | } |
3064 | |
3065 | llvm::Constant * |
3066 | CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) { |
3067 | llvm::Constant *ProtocolList = GenerateProtocolList({}); |
3068 | llvm::Constant *MethodList = GenerateProtocolMethodList({}); |
3069 | MethodList = llvm::ConstantExpr::getBitCast(MethodList, PtrToInt8Ty); |
3070 | |
3071 | |
3072 | ConstantInitBuilder Builder(CGM); |
3073 | auto Elements = Builder.beginStruct(); |
3074 | |
3075 | |
3076 | |
3077 | Elements.add(llvm::ConstantExpr::getIntToPtr( |
3078 | llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy)); |
3079 | |
3080 | Elements.add(MakeConstantString(ProtocolName, ".objc_protocol_name")); |
3081 | Elements.add(ProtocolList); |
3082 | Elements.add(MethodList); |
3083 | Elements.add(MethodList); |
3084 | Elements.add(MethodList); |
3085 | Elements.add(MethodList); |
3086 | Elements.add(NULLPtr); |
3087 | Elements.add(NULLPtr); |
3088 | return Elements.finishAndCreateGlobal(SymbolForProtocol(ProtocolName), |
3089 | CGM.getPointerAlign()); |
3090 | } |
3091 | |
3092 | void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) { |
3093 | if (PD->isNonRuntimeProtocol()) |
3094 | return; |
3095 | |
3096 | std::string ProtocolName = PD->getNameAsString(); |
3097 | |
3098 | |
3099 | if (const ObjCProtocolDecl *Def = PD->getDefinition()) |
3100 | PD = Def; |
3101 | |
3102 | SmallVector<std::string, 16> Protocols; |
3103 | for (const auto *PI : PD->protocols()) |
3104 | Protocols.push_back(PI->getNameAsString()); |
3105 | SmallVector<const ObjCMethodDecl*, 16> InstanceMethods; |
3106 | SmallVector<const ObjCMethodDecl*, 16> OptionalInstanceMethods; |
3107 | for (const auto *I : PD->instance_methods()) |
3108 | if (I->isOptional()) |
3109 | OptionalInstanceMethods.push_back(I); |
3110 | else |
3111 | InstanceMethods.push_back(I); |
3112 | |
3113 | SmallVector<const ObjCMethodDecl*, 16> ClassMethods; |
3114 | SmallVector<const ObjCMethodDecl*, 16> OptionalClassMethods; |
3115 | for (const auto *I : PD->class_methods()) |
3116 | if (I->isOptional()) |
3117 | OptionalClassMethods.push_back(I); |
3118 | else |
3119 | ClassMethods.push_back(I); |
3120 | |
3121 | llvm::Constant *ProtocolList = GenerateProtocolList(Protocols); |
3122 | llvm::Constant *InstanceMethodList = |
3123 | GenerateProtocolMethodList(InstanceMethods); |
3124 | llvm::Constant *ClassMethodList = |
3125 | GenerateProtocolMethodList(ClassMethods); |
3126 | llvm::Constant *OptionalInstanceMethodList = |
3127 | GenerateProtocolMethodList(OptionalInstanceMethods); |
3128 | llvm::Constant *OptionalClassMethodList = |
3129 | GenerateProtocolMethodList(OptionalClassMethods); |
3130 | |
3131 | |
3132 | |
3133 | |
3134 | |
3135 | |
3136 | |
3137 | llvm::Constant *PropertyList = |
3138 | GeneratePropertyList(nullptr, PD, false, false); |
3139 | llvm::Constant *OptionalPropertyList = |
3140 | GeneratePropertyList(nullptr, PD, false, true); |
3141 | |
3142 | |
3143 | |
3144 | |
3145 | |
3146 | ConstantInitBuilder Builder(CGM); |
3147 | auto Elements = Builder.beginStruct(); |
3148 | Elements.add( |
3149 | llvm::ConstantExpr::getIntToPtr( |
3150 | llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy)); |
3151 | Elements.add(MakeConstantString(ProtocolName)); |
3152 | Elements.add(ProtocolList); |
3153 | Elements.add(InstanceMethodList); |
3154 | Elements.add(ClassMethodList); |
3155 | Elements.add(OptionalInstanceMethodList); |
3156 | Elements.add(OptionalClassMethodList); |
3157 | Elements.add(PropertyList); |
3158 | Elements.add(OptionalPropertyList); |
3159 | ExistingProtocols[ProtocolName] = |
3160 | llvm::ConstantExpr::getBitCast( |
3161 | Elements.finishAndCreateGlobal(".objc_protocol", CGM.getPointerAlign()), |
3162 | IdTy); |
3163 | } |
3164 | void CGObjCGNU::GenerateProtocolHolderCategory() { |
3165 | |
3166 | |
3167 | ConstantInitBuilder Builder(CGM); |
3168 | auto Elements = Builder.beginStruct(); |
3169 | |
3170 | const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack"; |
3171 | const std::string CategoryName = "AnotherHack"; |
3172 | Elements.add(MakeConstantString(CategoryName)); |
3173 | Elements.add(MakeConstantString(ClassName)); |
3174 | |
3175 | Elements.addBitCast(GenerateMethodList( |
3176 | ClassName, CategoryName, {}, false), PtrTy); |
3177 | |
3178 | Elements.addBitCast(GenerateMethodList( |
3179 | ClassName, CategoryName, {}, true), PtrTy); |
3180 | |
3181 | |
3182 | ConstantInitBuilder ProtocolListBuilder(CGM); |
3183 | auto ProtocolList = ProtocolListBuilder.beginStruct(); |
3184 | ProtocolList.add(NULLPtr); |
3185 | ProtocolList.addInt(LongTy, ExistingProtocols.size()); |
3186 | auto ProtocolElements = ProtocolList.beginArray(PtrTy); |
3187 | for (auto iter = ExistingProtocols.begin(), endIter = ExistingProtocols.end(); |
3188 | iter != endIter ; iter++) { |
3189 | ProtocolElements.addBitCast(iter->getValue(), PtrTy); |
3190 | } |
3191 | ProtocolElements.finishAndAddTo(ProtocolList); |
3192 | Elements.addBitCast( |
3193 | ProtocolList.finishAndCreateGlobal(".objc_protocol_list", |
3194 | CGM.getPointerAlign()), |
3195 | PtrTy); |
3196 | Categories.push_back(llvm::ConstantExpr::getBitCast( |
3197 | Elements.finishAndCreateGlobal("", CGM.getPointerAlign()), |
3198 | PtrTy)); |
3199 | } |
3200 | |
3201 | |
3202 | |
3203 | |
3204 | |
3205 | |
3206 | |
3207 | |
3208 | |
3209 | |
3210 | |
3211 | |
3212 | llvm::Constant *CGObjCGNU::MakeBitField(ArrayRef<bool> bits) { |
3213 | int bitCount = bits.size(); |
3214 | int ptrBits = CGM.getDataLayout().getPointerSizeInBits(); |
3215 | if (bitCount < ptrBits) { |
3216 | uint64_t val = 1; |
3217 | for (int i=0 ; i<bitCount ; ++i) { |
3218 | if (bits[i]) val |= 1ULL<<(i+1); |
3219 | } |
3220 | return llvm::ConstantInt::get(IntPtrTy, val); |
3221 | } |
3222 | SmallVector<llvm::Constant *, 8> values; |
3223 | int v=0; |
3224 | while (v < bitCount) { |
3225 | int32_t word = 0; |
3226 | for (int i=0 ; (i<32) && (v<bitCount) ; ++i) { |
3227 | if (bits[v]) word |= 1<<i; |
3228 | v++; |
3229 | } |
3230 | values.push_back(llvm::ConstantInt::get(Int32Ty, word)); |
3231 | } |
3232 | |
3233 | ConstantInitBuilder builder(CGM); |
3234 | auto fields = builder.beginStruct(); |
3235 | fields.addInt(Int32Ty, values.size()); |
3236 | auto array = fields.beginArray(); |
3237 | for (auto v : values) array.add(v); |
3238 | array.finishAndAddTo(fields); |
3239 | |
3240 | llvm::Constant *GS = |
3241 | fields.finishAndCreateGlobal("", CharUnits::fromQuantity(4)); |
3242 | llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy); |
3243 | return ptr; |
3244 | } |
3245 | |
3246 | llvm::Constant *CGObjCGNU::GenerateCategoryProtocolList(const |
3247 | ObjCCategoryDecl *OCD) { |
3248 | const auto &RefPro = OCD->getReferencedProtocols(); |
3249 | const auto RuntimeProtos = |
3250 | GetRuntimeProtocolList(RefPro.begin(), RefPro.end()); |
3251 | SmallVector<std::string, 16> Protocols; |
3252 | for (const auto *PD : RuntimeProtos) |
3253 | Protocols.push_back(PD->getNameAsString()); |
3254 | return GenerateProtocolList(Protocols); |
3255 | } |
3256 | |
3257 | void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) { |
3258 | const ObjCInterfaceDecl *Class = OCD->getClassInterface(); |
3259 | std::string ClassName = Class->getNameAsString(); |
3260 | std::string CategoryName = OCD->getNameAsString(); |
3261 | |
3262 | |
3263 | const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl(); |
3264 | |
3265 | ConstantInitBuilder Builder(CGM); |
3266 | auto Elements = Builder.beginStruct(); |
3267 | Elements.add(MakeConstantString(CategoryName)); |
3268 | Elements.add(MakeConstantString(ClassName)); |
3269 | |
3270 | SmallVector<ObjCMethodDecl*, 16> InstanceMethods; |
3271 | InstanceMethods.insert(InstanceMethods.begin(), OCD->instmeth_begin(), |
3272 | OCD->instmeth_end()); |
3273 | Elements.addBitCast( |
3274 | GenerateMethodList(ClassName, CategoryName, InstanceMethods, false), |
3275 | PtrTy); |
3276 | |
3277 | |
3278 | SmallVector<ObjCMethodDecl*, 16> ClassMethods; |
3279 | ClassMethods.insert(ClassMethods.begin(), OCD->classmeth_begin(), |
3280 | OCD->classmeth_end()); |
3281 | Elements.addBitCast( |
3282 | GenerateMethodList(ClassName, CategoryName, ClassMethods, true), |
3283 | PtrTy); |
3284 | |
3285 | Elements.addBitCast(GenerateCategoryProtocolList(CatDecl), PtrTy); |
3286 | if (isRuntime(ObjCRuntime::GNUstep, 2)) { |
3287 | const ObjCCategoryDecl *Category = |
3288 | Class->FindCategoryDeclaration(OCD->getIdentifier()); |
3289 | if (Category) { |
3290 | |
3291 | Elements.addBitCast(GeneratePropertyList(OCD, Category, false), PtrTy); |
3292 | |
3293 | Elements.addBitCast(GeneratePropertyList(OCD, Category, true), PtrTy); |
3294 | } else { |
3295 | Elements.addNullPointer(PtrTy); |
3296 | Elements.addNullPointer(PtrTy); |
3297 | } |
3298 | } |
3299 | |
3300 | Categories.push_back(llvm::ConstantExpr::getBitCast( |
3301 | Elements.finishAndCreateGlobal( |
3302 | std::string(".objc_category_")+ClassName+CategoryName, |
3303 | CGM.getPointerAlign()), |
3304 | PtrTy)); |
3305 | } |
3306 | |
3307 | llvm::Constant *CGObjCGNU::GeneratePropertyList(const Decl *Container, |
3308 | const ObjCContainerDecl *OCD, |
3309 | bool isClassProperty, |
3310 | bool protocolOptionalProperties) { |
3311 | |
3312 | SmallVector<const ObjCPropertyDecl *, 16> Properties; |
3313 | llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet; |
3314 | bool isProtocol = isa<ObjCProtocolDecl>(OCD); |
3315 | ASTContext &Context = CGM.getContext(); |
3316 | |
3317 | std::function<void(const ObjCProtocolDecl *Proto)> collectProtocolProperties |
3318 | = [&](const ObjCProtocolDecl *Proto) { |
3319 | for (const auto *P : Proto->protocols()) |
3320 | collectProtocolProperties(P); |
3321 | for (const auto *PD : Proto->properties()) { |
3322 | if (isClassProperty != PD->isClassProperty()) |
3323 | continue; |
3324 | |
3325 | |
3326 | if (!isProtocol && !Context.getObjCPropertyImplDeclForPropertyDecl(PD, Container)) |
3327 | continue; |
3328 | if (!PropertySet.insert(PD->getIdentifier()).second) |
3329 | continue; |
3330 | Properties.push_back(PD); |
3331 | } |
3332 | }; |
3333 | |
3334 | if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) |
3335 | for (const ObjCCategoryDecl *ClassExt : OID->known_extensions()) |
3336 | for (auto *PD : ClassExt->properties()) { |
3337 | if (isClassProperty != PD->isClassProperty()) |
3338 | continue; |
3339 | PropertySet.insert(PD->getIdentifier()); |
3340 | Properties.push_back(PD); |
3341 | } |
3342 | |
3343 | for (const auto *PD : OCD->properties()) { |
3344 | if (isClassProperty != PD->isClassProperty()) |
3345 | continue; |
3346 | |
3347 | |
3348 | if (isProtocol && (protocolOptionalProperties != PD->isOptional())) |
3349 | continue; |
3350 | |
3351 | |
3352 | if (!PropertySet.insert(PD->getIdentifier()).second) |
3353 | continue; |
3354 | |
3355 | Properties.push_back(PD); |
3356 | } |
3357 | |
3358 | if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) |
3359 | for (const auto *P : OID->all_referenced_protocols()) |
3360 | collectProtocolProperties(P); |
3361 | else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) |
3362 | for (const auto *P : CD->protocols()) |
3363 | collectProtocolProperties(P); |
3364 | |
3365 | auto numProperties = Properties.size(); |
3366 | |
3367 | if (numProperties == 0) |
3368 | return NULLPtr; |
3369 | |
3370 | ConstantInitBuilder builder(CGM); |
3371 | auto propertyList = builder.beginStruct(); |
3372 | auto properties = PushPropertyListHeader(propertyList, numProperties); |
3373 | |
3374 | |
3375 | |
3376 | for (auto *property : Properties) { |
3377 | bool isSynthesized = false; |
3378 | bool isDynamic = false; |
3379 | if (!isProtocol) { |
3380 | auto *propertyImpl = Context.getObjCPropertyImplDeclForPropertyDecl(property, Container); |
3381 | if (propertyImpl) { |
3382 | isSynthesized = (propertyImpl->getPropertyImplementation() == |
3383 | ObjCPropertyImplDecl::Synthesize); |
3384 | isDynamic = (propertyImpl->getPropertyImplementation() == |
3385 | ObjCPropertyImplDecl::Dynamic); |
3386 | } |
3387 | } |
3388 | PushProperty(properties, property, Container, isSynthesized, isDynamic); |
3389 | } |
3390 | properties.finishAndAddTo(propertyList); |
3391 | |
3392 | return propertyList.finishAndCreateGlobal(".objc_property_list", |
3393 | CGM.getPointerAlign()); |
3394 | } |
3395 | |
3396 | void CGObjCGNU::RegisterAlias(const ObjCCompatibleAliasDecl *OAD) { |
3397 | |
3398 | ObjCInterfaceDecl *ClassDecl = |
3399 | const_cast<ObjCInterfaceDecl *>(OAD->getClassInterface()); |
3400 | ClassAliases.emplace_back(ClassDecl->getNameAsString(), |
3401 | OAD->getNameAsString()); |
3402 | } |
3403 | |
3404 | void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) { |
3405 | ASTContext &Context = CGM.getContext(); |
3406 | |
3407 | |
3408 | const ObjCInterfaceDecl * SuperClassDecl = |
3409 | OID->getClassInterface()->getSuperClass(); |
3410 | std::string SuperClassName; |
3411 | if (SuperClassDecl) { |
3412 | SuperClassName = SuperClassDecl->getNameAsString(); |
3413 | EmitClassRef(SuperClassName); |
3414 | } |
3415 | |
3416 | |
3417 | ObjCInterfaceDecl *ClassDecl = |
3418 | const_cast<ObjCInterfaceDecl *>(OID->getClassInterface()); |
3419 | std::string ClassName = ClassDecl->getNameAsString(); |
3420 | |
3421 | |
3422 | |
3423 | std::string classSymbolName = "__objc_class_name_" + ClassName; |
3424 | if (auto *symbol = TheModule.getGlobalVariable(classSymbolName)) { |
3425 | symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0)); |
3426 | } else { |
3427 | new llvm::GlobalVariable(TheModule, LongTy, false, |
3428 | llvm::GlobalValue::ExternalLinkage, |
3429 | llvm::ConstantInt::get(LongTy, 0), |
3430 | classSymbolName); |
3431 | } |
3432 | |
3433 | |
3434 | int instanceSize = |
3435 | Context.getASTObjCImplementationLayout(OID).getSize().getQuantity(); |
3436 | |
3437 | |
3438 | SmallVector<llvm::Constant*, 16> IvarNames; |
3439 | SmallVector<llvm::Constant*, 16> IvarTypes; |
3440 | SmallVector<llvm::Constant*, 16> IvarOffsets; |
3441 | SmallVector<llvm::Constant*, 16> IvarAligns; |
3442 | SmallVector<Qualifiers::ObjCLifetime, 16> IvarOwnership; |
3443 | |
3444 | ConstantInitBuilder IvarOffsetBuilder(CGM); |
3445 | auto IvarOffsetValues = IvarOffsetBuilder.beginArray(PtrToIntTy); |
3446 | SmallVector<bool, 16> WeakIvars; |
3447 | SmallVector<bool, 16> StrongIvars; |
3448 | |
3449 | int superInstanceSize = !SuperClassDecl ? 0 : |
3450 | Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity(); |
3451 | |
3452 | |
3453 | if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { |
3454 | instanceSize = 0 - (instanceSize - superInstanceSize); |
3455 | } |
3456 | |
3457 | for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD; |
3458 | IVD = IVD->getNextIvar()) { |
3459 | |
3460 | IvarNames.push_back(MakeConstantString(IVD->getNameAsString())); |
3461 | |
3462 | std::string TypeStr; |
3463 | Context.getObjCEncodingForType(IVD->getType(), TypeStr, IVD); |
3464 | IvarTypes.push_back(MakeConstantString(TypeStr)); |
3465 | IvarAligns.push_back(llvm::ConstantInt::get(IntTy, |
3466 | Context.getTypeSize(IVD->getType()))); |
3467 | |
3468 | uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD); |
3469 | uint64_t Offset = BaseOffset; |
3470 | if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { |
3471 | Offset = BaseOffset - superInstanceSize; |
3472 | } |
3473 | llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset); |
3474 | |
3475 | std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." + |
3476 | IVD->getNameAsString(); |
3477 | |
3478 | llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName); |
3479 | if (OffsetVar) { |
3480 | OffsetVar->setInitializer(OffsetValue); |
3481 | |
3482 | |
3483 | |
3484 | OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage); |
3485 | } else |
3486 | OffsetVar = new llvm::GlobalVariable(TheModule, Int32Ty, |
3487 | false, llvm::GlobalValue::ExternalLinkage, |
3488 | OffsetValue, OffsetName); |
3489 | IvarOffsets.push_back(OffsetValue); |
3490 | IvarOffsetValues.add(OffsetVar); |
3491 | Qualifiers::ObjCLifetime lt = IVD->getType().getQualifiers().getObjCLifetime(); |
3492 | IvarOwnership.push_back(lt); |
3493 | switch (lt) { |
3494 | case Qualifiers::OCL_Strong: |
3495 | StrongIvars.push_back(true); |
3496 | WeakIvars.push_back(false); |
3497 | break; |
3498 | case Qualifiers::OCL_Weak: |
3499 | StrongIvars.push_back(false); |
3500 | WeakIvars.push_back(true); |
3501 | break; |
3502 | default: |
3503 | StrongIvars.push_back(false); |
3504 | WeakIvars.push_back(false); |
3505 | } |
3506 | } |
3507 | llvm::Constant *StrongIvarBitmap = MakeBitField(StrongIvars); |
3508 | llvm::Constant *WeakIvarBitmap = MakeBitField(WeakIvars); |
3509 | llvm::GlobalVariable *IvarOffsetArray = |
3510 | IvarOffsetValues.finishAndCreateGlobal(".ivar.offsets", |
3511 | CGM.getPointerAlign()); |
3512 | |
3513 | |
3514 | SmallVector<const ObjCMethodDecl*, 16> InstanceMethods; |
3515 | InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(), |
3516 | OID->instmeth_end()); |
3517 | |
3518 | SmallVector<const ObjCMethodDecl*, 16> ClassMethods; |
3519 | ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(), |
3520 | OID->classmeth_end()); |
3521 | |
3522 | llvm::Constant *Properties = GeneratePropertyList(OID, ClassDecl); |
3523 | |
3524 | |
3525 | auto RefProtocols = ClassDecl->protocols(); |
3526 | auto RuntimeProtocols = |
3527 | GetRuntimeProtocolList(RefProtocols.begin(), RefProtocols.end()); |
3528 | SmallVector<std::string, 16> Protocols; |
3529 | for (const auto *I : RuntimeProtocols) |
3530 | Protocols.push_back(I->getNameAsString()); |
3531 | |
3532 | |
3533 | llvm::Constant *SuperClass; |
3534 | if (!SuperClassName.empty()) { |
3535 | SuperClass = MakeConstantString(SuperClassName, ".super_class_name"); |
3536 | } else { |
3537 | SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty); |
3538 | } |
3539 | |
3540 | SmallVector<llvm::Constant*, 1> empty; |
3541 | |
3542 | llvm::Constant *MethodList = GenerateMethodList(ClassName, "", |
3543 | InstanceMethods, false); |
3544 | llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "", |
3545 | ClassMethods, true); |
3546 | llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes, |
3547 | IvarOffsets, IvarAligns, IvarOwnership); |
3548 | |
3549 | |
3550 | |
3551 | |
3552 | |
3553 | |
3554 | |
3555 | |
3556 | |
3557 | |
3558 | llvm::Type *IndexTy = Int32Ty; |
3559 | llvm::Constant *offsetPointerIndexes[] = {Zeros[0], |
3560 | llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 2 : 1), nullptr, |
3561 | llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 3 : 2) }; |
3562 | |
3563 | unsigned ivarIndex = 0; |
3564 | for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD; |
3565 | IVD = IVD->getNextIvar()) { |
3566 | const std::string Name = GetIVarOffsetVariableName(ClassDecl, IVD); |
3567 | offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex); |
3568 | |
3569 | llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr( |
3570 | cast<llvm::GlobalVariable>(IvarList)->getValueType(), IvarList, |
3571 | offsetPointerIndexes); |
3572 | |
3573 | llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name); |
3574 | if (offset) { |
3575 | offset->setInitializer(offsetValue); |
3576 | |
3577 | |
3578 | |
3579 | offset->setLinkage(llvm::GlobalValue::ExternalLinkage); |
3580 | } else |
3581 | |
3582 | new llvm::GlobalVariable(TheModule, offsetValue->getType(), |
3583 | false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name); |
3584 | ++ivarIndex; |
3585 | } |
3586 | llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0); |
3587 | |
3588 | |
3589 | llvm::Constant *MetaClassStruct = GenerateClassStructure( |
3590 | NULLPtr, NULLPtr, 0x12L, ClassName.c_str(), nullptr, Zeros[0], |
3591 | NULLPtr, ClassMethodList, NULLPtr, NULLPtr, |
3592 | GeneratePropertyList(OID, ClassDecl, true), ZeroPtr, ZeroPtr, true); |
3593 | CGM.setGVProperties(cast<llvm::GlobalValue>(MetaClassStruct), |
3594 | OID->getClassInterface()); |
3595 | |
3596 | |
3597 | llvm::Constant *ClassStruct = GenerateClassStructure( |
3598 | MetaClassStruct, SuperClass, 0x11L, ClassName.c_str(), nullptr, |
3599 | llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList, |
3600 | GenerateProtocolList(Protocols), IvarOffsetArray, Properties, |
3601 | StrongIvarBitmap, WeakIvarBitmap); |
3602 | CGM.setGVProperties(cast<llvm::GlobalValue>(ClassStruct), |
3603 | OID->getClassInterface()); |
3604 | |
3605 | |
3606 | if (ClassPtrAlias) { |
3607 | ClassPtrAlias->replaceAllUsesWith( |
3608 | llvm::ConstantExpr::getBitCast(ClassStruct, IdTy)); |
3609 | ClassPtrAlias->eraseFromParent(); |
3610 | ClassPtrAlias = nullptr; |
3611 | } |
3612 | if (MetaClassPtrAlias) { |
3613 | MetaClassPtrAlias->replaceAllUsesWith( |
3614 | llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy)); |
3615 | MetaClassPtrAlias->eraseFromParent(); |
3616 | MetaClassPtrAlias = nullptr; |
3617 | } |
3618 | |
3619 | |
3620 | ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty); |
3621 | Classes.push_back(ClassStruct); |
3622 | } |
3623 | |
3624 | llvm::Function *CGObjCGNU::ModuleInitFunction() { |
3625 | |
3626 | if (Classes.empty() && Categories.empty() && ConstantStrings.empty() && |
3627 | ExistingProtocols.empty() && SelectorTable.empty()) |
3628 | return nullptr; |
3629 | |
3630 | |
3631 | GenerateProtocolHolderCategory(); |
3632 | |
3633 | llvm::StructType *selStructTy = |
3634 | dyn_cast<llvm::StructType>(SelectorTy->getElementType()); |
3635 | llvm::Type *selStructPtrTy = SelectorTy; |
3636 | if (!selStructTy) { |
3637 | selStructTy = llvm::StructType::get(CGM.getLLVMContext(), |
3638 | { PtrToInt8Ty, PtrToInt8Ty }); |
3639 | selStructPtrTy = llvm::PointerType::getUnqual(selStructTy); |
3640 | } |
3641 | |
3642 | |
3643 | llvm::Constant *statics = NULLPtr; |
3644 | if (!ConstantStrings.empty()) { |
3645 | llvm::GlobalVariable *fileStatics = [&] { |
3646 | ConstantInitBuilder builder(CGM); |
3647 | auto staticsStruct = builder.beginStruct(); |
3648 | |
3649 | StringRef stringClass = CGM.getLangOpts().ObjCConstantStringClass; |
3650 | if (stringClass.empty()) stringClass = "NXConstantString"; |
3651 | staticsStruct.add(MakeConstantString(stringClass, |
3652 | ".objc_static_class_name")); |
3653 | |
3654 | auto array = staticsStruct.beginArray(); |
3655 | array.addAll(ConstantStrings); |
3656 | array.add(NULLPtr); |
3657 | array.finishAndAddTo(staticsStruct); |
3658 | |
3659 | return staticsStruct.finishAndCreateGlobal(".objc_statics", |
3660 | CGM.getPointerAlign()); |
3661 | }(); |
3662 | |
3663 | ConstantInitBuilder builder(CGM); |
3664 | auto allStaticsArray = builder.beginArray(fileStatics->getType()); |
3665 | allStaticsArray.add(fileStatics); |
3666 | allStaticsArray.addNullPointer(fileStatics->getType()); |
3667 | |
3668 | statics = allStaticsArray.finishAndCreateGlobal(".objc_statics_ptr", |
3669 | CGM.getPointerAlign()); |
3670 | statics = llvm::ConstantExpr::getBitCast(statics, PtrTy); |
3671 | } |
3672 | |
3673 | |
3674 | |
3675 | SmallVector<llvm::GlobalAlias*, 16> selectorAliases; |
3676 | unsigned selectorCount; |
3677 | |
3678 | |
3679 | llvm::GlobalVariable *selectorList = [&] { |
3680 | ConstantInitBuilder builder(CGM); |
3681 | auto selectors = builder.beginArray(selStructTy); |
3682 | auto &table = SelectorTable; |
3683 | std::vector<Selector> allSelectors; |
3684 | for (auto &entry : table) |
3685 | allSelectors.push_back(entry.first); |
3686 | llvm::sort(allSelectors); |
3687 | |
3688 | for (auto &untypedSel : allSelectors) { |
3689 | std::string selNameStr = untypedSel.getAsString(); |
3690 | llvm::Constant *selName = ExportUniqueString(selNameStr, ".objc_sel_name"); |
3691 | |
3692 | for (TypedSelector &sel : table[untypedSel]) { |
3693 | llvm::Constant *selectorTypeEncoding = NULLPtr; |
3694 | if (!sel.first.empty()) |
3695 | selectorTypeEncoding = |
3696 | MakeConstantString(sel.first, ".objc_sel_types"); |
3697 | |
3698 | auto selStruct = selectors.beginStruct(selStructTy); |
3699 | selStruct.add(selName); |
3700 | selStruct.add(selectorTypeEncoding); |
3701 | selStruct.finishAndAddTo(selectors); |
3702 | |
3703 | |
3704 | selectorAliases.push_back(sel.second); |
3705 | } |
3706 | } |
3707 | |
3708 | |
3709 | selectorCount = selectors.size(); |
3710 | |
3711 | |
3712 | |
3713 | |
3714 | |
3715 | auto selStruct = selectors.beginStruct(selStructTy); |
3716 | selStruct.add(NULLPtr); |
3717 | selStruct.add(NULLPtr); |
3718 | selStruct.finishAndAddTo(selectors); |
3719 | |
3720 | return selectors.finishAndCreateGlobal(".objc_selector_list", |
3721 | CGM.getPointerAlign()); |
3722 | }(); |
3723 | |
3724 | |
3725 | for (unsigned i = 0; i < selectorCount; ++i) { |
3726 | llvm::Constant *idxs[] = { |
3727 | Zeros[0], |
3728 | llvm::ConstantInt::get(Int32Ty, i) |
3729 | }; |
3730 | |
3731 | llvm::Constant *selPtr = llvm::ConstantExpr::getGetElementPtr( |
3732 | selectorList->getValueType(), selectorList, idxs); |
3733 | |
3734 | |
3735 | selPtr = llvm::ConstantExpr::getBitCast(selPtr, SelectorTy); |
3736 | selectorAliases[i]->replaceAllUsesWith(selPtr); |
3737 | selectorAliases[i]->eraseFromParent(); |
3738 | } |
3739 | |
3740 | llvm::GlobalVariable *symtab = [&] { |
3741 | ConstantInitBuilder builder(CGM); |
3742 | auto symtab = builder.beginStruct(); |
3743 | |
3744 | |
3745 | symtab.addInt(LongTy, selectorCount); |
3746 | |
3747 | symtab.addBitCast(selectorList, selStructPtrTy); |
3748 | |
3749 | |
3750 | symtab.addInt(CGM.Int16Ty, Classes.size()); |
3751 | |
3752 | symtab.addInt(CGM.Int16Ty, Categories.size()); |
3753 | |
3754 | |
3755 | auto classList = symtab.beginArray(PtrToInt8Ty); |
3756 | classList.addAll(Classes); |
3757 | classList.addAll(Categories); |
3758 | |
3759 | classList.add(statics); |
3760 | classList.add(NULLPtr); |
3761 | classList.finishAndAddTo(symtab); |
3762 | |
3763 | |
3764 | return symtab.finishAndCreateGlobal("", CGM.getPointerAlign()); |
3765 | }(); |
3766 | |
3767 | |
3768 | |
3769 | llvm::Constant *module = [&] { |
3770 | llvm::Type *moduleEltTys[] = { |
3771 | LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy |
3772 | }; |
3773 | llvm::StructType *moduleTy = |
3774 | llvm::StructType::get(CGM.getLLVMContext(), |
3775 | makeArrayRef(moduleEltTys).drop_back(unsigned(RuntimeVersion < 10))); |
3776 | |
3777 | ConstantInitBuilder builder(CGM); |
3778 | auto module = builder.beginStruct(moduleTy); |
3779 | |
3780 | module.addInt(LongTy, RuntimeVersion); |
3781 | |
3782 | module.addInt(LongTy, CGM.getDataLayout().getTypeStoreSize(moduleTy)); |
3783 | |
3784 | |
3785 | SourceManager &SM = CGM.getContext().getSourceManager(); |
3786 | const FileEntry *mainFile = SM.getFileEntryForID(SM.getMainFileID()); |
3787 | std::string path = |
3788 | (Twine(mainFile->getDir()->getName()) + "/" + mainFile->getName()).str(); |
3789 | module.add(MakeConstantString(path, ".objc_source_file_name")); |
3790 | module.add(symtab); |
3791 | |
3792 | if (RuntimeVersion >= 10) { |
3793 | switch (CGM.getLangOpts().getGC()) { |
3794 | case LangOptions::GCOnly: |
3795 | module.addInt(IntTy, 2); |
3796 | break; |
3797 | case LangOptions::NonGC: |
3798 | if (CGM.getLangOpts().ObjCAutoRefCount) |
3799 | module.addInt(IntTy, 1); |
3800 | else |
3801 | module.addInt(IntTy, 0); |
3802 | break; |
3803 | case LangOptions::HybridGC: |
3804 | module.addInt(IntTy, 1); |
3805 | break; |
3806 | } |
3807 | } |
3808 | |
3809 | return module.finishAndCreateGlobal("", CGM.getPointerAlign()); |
3810 | }(); |
3811 | |
3812 | |
3813 | |
3814 | llvm::Function * LoadFunction = llvm::Function::Create( |
3815 | llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false), |
3816 | llvm::GlobalValue::InternalLinkage, ".objc_load_function", |
3817 | &TheModule); |
3818 | llvm::BasicBlock *EntryBB = |
3819 | llvm::BasicBlock::Create(VMContext, "entry", LoadFunction); |
3820 | CGBuilderTy Builder(CGM, VMContext); |
3821 | Builder.SetInsertPoint(EntryBB); |
3822 | |
3823 | llvm::FunctionType *FT = |
3824 | llvm::FunctionType::get(Builder.getVoidTy(), module->getType(), true); |
3825 | llvm::FunctionCallee Register = |
3826 | CGM.CreateRuntimeFunction(FT, "__objc_exec_class"); |
3827 | Builder.CreateCall(Register, module); |
3828 | |
3829 | if (!ClassAliases.empty()) { |
3830 | llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty}; |
3831 | llvm::FunctionType *RegisterAliasTy = |
3832 | llvm::FunctionType::get(Builder.getVoidTy(), |
3833 | ArgTypes, false); |
3834 | llvm::Function *RegisterAlias = llvm::Function::Create( |
3835 | RegisterAliasTy, |
3836 | llvm::GlobalValue::ExternalWeakLinkage, "class_registerAlias_np", |
3837 | &TheModule); |
3838 | llvm::BasicBlock *AliasBB = |
3839 | llvm::BasicBlock::Create(VMContext, "alias", LoadFunction); |
3840 | llvm::BasicBlock *NoAliasBB = |
3841 | llvm::BasicBlock::Create(VMContext, "no_alias", LoadFunction); |
3842 | |
3843 | |
3844 | llvm::Value *HasRegisterAlias = Builder.CreateICmpNE(RegisterAlias, |
3845 | llvm::Constant::getNullValue(RegisterAlias->getType())); |
3846 | Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB); |
3847 | |
3848 | |
3849 | Builder.SetInsertPoint(AliasBB); |
3850 | |
3851 | for (std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin(); |
3852 | iter != ClassAliases.end(); ++iter) { |
3853 | llvm::Constant *TheClass = |
3854 | TheModule.getGlobalVariable("_OBJC_CLASS_" + iter->first, true); |
3855 | if (TheClass) { |
3856 | TheClass = llvm::ConstantExpr::getBitCast(TheClass, PtrTy); |
3857 | Builder.CreateCall(RegisterAlias, |
3858 | {TheClass, MakeConstantString(iter->second)}); |
3859 | } |
3860 | } |
3861 | |
3862 | Builder.CreateBr(NoAliasBB); |
3863 | |
3864 | |
3865 | Builder.SetInsertPoint(NoAliasBB); |
3866 | } |
3867 | Builder.CreateRetVoid(); |
3868 | |
3869 | return LoadFunction; |
3870 | } |
3871 | |
3872 | llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD, |
3873 | const ObjCContainerDecl *CD) { |
3874 | CodeGenTypes &Types = CGM.getTypes(); |
3875 | llvm::FunctionType *MethodTy = |
3876 | Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD)); |
3877 | std::string FunctionName = getSymbolNameForMethod(OMD); |
3878 | |
3879 | llvm::Function *Method |
3880 | = llvm::Function::Create(MethodTy, |
3881 | llvm::GlobalValue::InternalLinkage, |
3882 | FunctionName, |
3883 | &TheModule); |
3884 | return Method; |
3885 | } |
3886 | |
3887 | void CGObjCGNU::GenerateDirectMethodPrologue(CodeGenFunction &CGF, |
3888 | llvm::Function *Fn, |
3889 | const ObjCMethodDecl *OMD, |
3890 | const ObjCContainerDecl *CD) { |
3891 | |
3892 | } |
3893 | |
3894 | llvm::FunctionCallee CGObjCGNU::GetPropertyGetFunction() { |
3895 | return GetPropertyFn; |
3896 | } |
3897 | |
3898 | llvm::FunctionCallee CGObjCGNU::GetPropertySetFunction() { |
3899 | return SetPropertyFn; |
3900 | } |
3901 | |
3902 | llvm::FunctionCallee CGObjCGNU::GetOptimizedPropertySetFunction(bool atomic, |
3903 | bool copy) { |
3904 | return nullptr; |
3905 | } |
3906 | |
3907 | llvm::FunctionCallee CGObjCGNU::GetGetStructFunction() { |
3908 | return GetStructPropertyFn; |
3909 | } |
3910 | |
3911 | llvm::FunctionCallee CGObjCGNU::GetSetStructFunction() { |
3912 | return SetStructPropertyFn; |
3913 | } |
3914 | |
3915 | llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectGetFunction() { |
3916 | return nullptr; |
3917 | } |
3918 | |
3919 | llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectSetFunction() { |
3920 | return nullptr; |
3921 | } |
3922 | |
3923 | llvm::FunctionCallee CGObjCGNU::EnumerationMutationFunction() { |
3924 | return EnumerationMutationFn; |
3925 | } |
3926 | |
3927 | void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF, |
3928 | const ObjCAtSynchronizedStmt &S) { |
3929 | EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn); |
3930 | } |
3931 | |
3932 | |
3933 | void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF, |
3934 | const ObjCAtTryStmt &S) { |
3935 | |
3936 | |
3937 | |
3938 | |
3939 | |
3940 | |
3941 | |
3942 | |
3943 | |
3944 | |
3945 | |
3946 | EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn); |
3947 | } |
3948 | |
3949 | void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF, |
3950 | const ObjCAtThrowStmt &S, |
3951 | bool ClearInsertionPoint) { |
3952 | llvm::Value *ExceptionAsObject; |
3953 | bool isRethrow = false; |
3954 | |
3955 | if (const Expr *ThrowExpr = S.getThrowExpr()) { |
3956 | llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr); |
3957 | ExceptionAsObject = Exception; |
3958 | } else { |
3959 | assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && |
3960 | "Unexpected rethrow outside @catch block."); |
3961 | ExceptionAsObject = CGF.ObjCEHValueStack.back(); |
3962 | isRethrow = true; |
3963 | } |
3964 | if (isRethrow && usesSEHExceptions) { |
3965 | |
3966 | |
3967 | |
3968 | |
3969 | |
3970 | |
3971 | |
3972 | llvm::CallBase *Throw = CGF.EmitRuntimeCallOrInvoke(ExceptionReThrowFn); |
3973 | Throw->setDoesNotReturn(); |
3974 | } |
3975 | else { |
3976 | ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy); |
3977 | llvm::CallBase *Throw = |
3978 | CGF.EmitRuntimeCallOrInvoke(ExceptionThrowFn, ExceptionAsObject); |
3979 | Throw->setDoesNotReturn(); |
3980 | } |
3981 | CGF.Builder.CreateUnreachable(); |
3982 | if (ClearInsertionPoint) |
3983 | CGF.Builder.ClearInsertionPoint(); |
3984 | } |
3985 | |
3986 | llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF, |
3987 | Address AddrWeakObj) { |
3988 | CGBuilderTy &B = CGF.Builder; |
3989 | AddrWeakObj = EnforceType(B, AddrWeakObj, PtrToIdTy); |
3990 | return B.CreateCall(WeakReadFn, AddrWeakObj.getPointer()); |
3991 | } |
3992 | |
3993 | void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF, |
3994 | llvm::Value *src, Address dst) { |
3995 | CGBuilderTy &B = CGF.Builder; |
3996 | src = EnforceType(B, src, IdTy); |
3997 | dst = EnforceType(B, dst, PtrToIdTy); |
3998 | B.CreateCall(WeakAssignFn, {src, dst.getPointer()}); |
3999 | } |
4000 | |
4001 | void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF, |
4002 | llvm::Value *src, Address dst, |
4003 | bool threadlocal) { |
4004 | CGBuilderTy &B = CGF.Builder; |
4005 | src = EnforceType(B, src, IdTy); |
4006 | dst = EnforceType(B, dst, PtrToIdTy); |
4007 | |
4008 | assert(!threadlocal && "EmitObjCGlobalAssign - Threal Local API NYI"); |
4009 | B.CreateCall(GlobalAssignFn, {src, dst.getPointer()}); |
4010 | } |
4011 | |
4012 | void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF, |
4013 | llvm::Value *src, Address dst, |
4014 | llvm::Value *ivarOffset) { |
4015 | CGBuilderTy &B = CGF.Builder; |
4016 | src = EnforceType(B, src, IdTy); |
4017 | dst = EnforceType(B, dst, IdTy); |
4018 | B.CreateCall(IvarAssignFn, {src, dst.getPointer(), ivarOffset}); |
4019 | } |
4020 | |
4021 | void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF, |
4022 | llvm::Value *src, Address dst) { |
4023 | CGBuilderTy &B = CGF.Builder; |
4024 | src = EnforceType(B, src, IdTy); |
4025 | dst = EnforceType(B, dst, PtrToIdTy); |
4026 | B.CreateCall(StrongCastAssignFn, {src, dst.getPointer()}); |
4027 | } |
4028 | |
4029 | void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF, |
4030 | Address DestPtr, |
4031 | Address SrcPtr, |
4032 | llvm::Value *Size) { |
4033 | CGBuilderTy &B = CGF.Builder; |
4034 | DestPtr = EnforceType(B, DestPtr, PtrTy); |
4035 | SrcPtr = EnforceType(B, SrcPtr, PtrTy); |
4036 | |
4037 | B.CreateCall(MemMoveFn, {DestPtr.getPointer(), SrcPtr.getPointer(), Size}); |
4038 | } |
4039 | |
4040 | llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable( |
4041 | const ObjCInterfaceDecl *ID, |
4042 | const ObjCIvarDecl *Ivar) { |
4043 | const std::string Name = GetIVarOffsetVariableName(ID, Ivar); |
4044 | |
4045 | |
4046 | |
4047 | llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name); |
4048 | if (!IvarOffsetPointer) |
4049 | IvarOffsetPointer = new llvm::GlobalVariable(TheModule, |
4050 | llvm::Type::getInt32PtrTy(VMContext), false, |
4051 | llvm::GlobalValue::ExternalLinkage, nullptr, Name); |
4052 | return IvarOffsetPointer; |
4053 | } |
4054 | |
4055 | LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF, |
4056 | QualType ObjectTy, |
4057 | llvm::Value *BaseValue, |
4058 | const ObjCIvarDecl *Ivar, |
4059 | unsigned CVRQualifiers) { |
4060 | const ObjCInterfaceDecl *ID = |
4061 | ObjectTy->castAs<ObjCObjectType>()->getInterface(); |
4062 | return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, |
4063 | EmitIvarOffset(CGF, ID, Ivar)); |
4064 | } |
4065 | |
4066 | static const ObjCInterfaceDecl *FindIvarInterface(ASTContext &Context, |
4067 | const ObjCInterfaceDecl *OID, |
4068 | const ObjCIvarDecl *OIVD) { |
4069 | for (const ObjCIvarDecl *next = OID->all_declared_ivar_begin(); next; |
4070 | next = next->getNextIvar()) { |
4071 | if (OIVD == next) |
4072 | return OID; |
4073 | } |
4074 | |
4075 | |
4076 | if (const ObjCInterfaceDecl *Super = OID->getSuperClass()) |
4077 | return FindIvarInterface(Context, Super, OIVD); |
4078 | |
4079 | return nullptr; |
4080 | } |
4081 | |
4082 | llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF, |
4083 | const ObjCInterfaceDecl *Interface, |
4084 | const ObjCIvarDecl *Ivar) { |
4085 | if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { |
4086 | Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar); |
4087 | |
4088 | |
4089 | |
4090 | |
4091 | if (RuntimeVersion < 10 || |
4092 | CGF.CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment()) |
4093 | return CGF.Builder.CreateZExtOrBitCast( |
4094 | CGF.Builder.CreateAlignedLoad( |
4095 | Int32Ty, CGF.Builder.CreateAlignedLoad( |
4096 | llvm::Type::getInt32PtrTy(VMContext), |
4097 | ObjCIvarOffsetVariable(Interface, Ivar), |
4098 | CGF.getPointerAlign(), "ivar"), |
4099 | CharUnits::fromQuantity(4)), |
4100 | PtrDiffTy); |
4101 | std::string name = "__objc_ivar_offset_value_" + |
4102 | Interface->getNameAsString() +"." + Ivar->getNameAsString(); |
4103 | CharUnits Align = CGM.getIntAlign(); |
4104 | llvm::Value *Offset = TheModule.getGlobalVariable(name); |
4105 | if (!Offset) { |
4106 | auto GV = new llvm::GlobalVariable(TheModule, IntTy, |
4107 | false, llvm::GlobalValue::LinkOnceAnyLinkage, |
4108 | llvm::Constant::getNullValue(IntTy), name); |
4109 | GV->setAlignment(Align.getAsAlign()); |
4110 | Offset = GV; |
4111 | } |
4112 | Offset = CGF.Builder.CreateAlignedLoad(IntTy, Offset, Align); |
4113 | if (Offset->getType() != PtrDiffTy) |
4114 | Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy); |
4115 | return Offset; |
4116 | } |
4117 | uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar); |
4118 | return llvm::ConstantInt::get(PtrDiffTy, Offset, true); |
4119 | } |
4120 | |
4121 | CGObjCRuntime * |
4122 | clang::CodeGen::CreateGNUObjCRuntime(CodeGenModule &CGM) { |
4123 | auto Runtime = CGM.getLangOpts().ObjCRuntime; |
4124 | switch (Runtime.getKind()) { |
4125 | case ObjCRuntime::GNUstep: |
4126 | if (Runtime.getVersion() >= VersionTuple(2, 0)) |
4127 | return new CGObjCGNUstep2(CGM); |
4128 | return new CGObjCGNUstep(CGM); |
4129 | |
4130 | case ObjCRuntime::GCC: |
4131 | return new CGObjCGCC(CGM); |
4132 | |
4133 | case ObjCRuntime::ObjFW: |
4134 | return new CGObjCObjFW(CGM); |
4135 | |
4136 | case ObjCRuntime::FragileMacOSX: |
4137 | case ObjCRuntime::MacOSX: |
4138 | case ObjCRuntime::iOS: |
4139 | case ObjCRuntime::WatchOS: |
4140 | llvm_unreachable("these runtimes are not GNU runtimes"); |
4141 | } |
4142 | llvm_unreachable("bad runtime"); |
4143 | } |