1 //===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This provides Objective-C code generation targeting the Apple runtime. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "CGBlocks.h" 14 #include "CGCleanup.h" 15 #include "CGObjCRuntime.h" 16 #include "CGRecordLayout.h" 17 #include "CodeGenFunction.h" 18 #include "CodeGenModule.h" 19 #include "clang/AST/ASTContext.h" 20 #include "clang/AST/Attr.h" 21 #include "clang/AST/Decl.h" 22 #include "clang/AST/DeclObjC.h" 23 #include "clang/AST/Mangle.h" 24 #include "clang/AST/RecordLayout.h" 25 #include "clang/AST/StmtObjC.h" 26 #include "clang/Basic/CodeGenOptions.h" 27 #include "clang/Basic/LangOptions.h" 28 #include "clang/CodeGen/CGFunctionInfo.h" 29 #include "clang/CodeGen/ConstantInitBuilder.h" 30 #include "llvm/ADT/CachedHashString.h" 31 #include "llvm/ADT/DenseSet.h" 32 #include "llvm/ADT/SetVector.h" 33 #include "llvm/ADT/SmallPtrSet.h" 34 #include "llvm/ADT/SmallString.h" 35 #include "llvm/ADT/UniqueVector.h" 36 #include "llvm/IR/DataLayout.h" 37 #include "llvm/IR/InlineAsm.h" 38 #include "llvm/IR/IntrinsicInst.h" 39 #include "llvm/IR/LLVMContext.h" 40 #include "llvm/IR/Module.h" 41 #include "llvm/Support/ScopedPrinter.h" 42 #include "llvm/Support/raw_ostream.h" 43 #include <cstdio> 44 45 using namespace clang; 46 using namespace CodeGen; 47 48 namespace { 49 50 // FIXME: We should find a nicer way to make the labels for metadata, string 51 // concatenation is lame. 52 53 class ObjCCommonTypesHelper { 54 protected: 55 llvm::LLVMContext &VMContext; 56 57 private: 58 // The types of these functions don't really matter because we 59 // should always bitcast before calling them. 60 61 /// id objc_msgSend (id, SEL, ...) 62 /// 63 /// The default messenger, used for sends whose ABI is unchanged from 64 /// the all-integer/pointer case. 65 llvm::FunctionCallee getMessageSendFn() const { 66 // Add the non-lazy-bind attribute, since objc_msgSend is likely to 67 // be called a lot. 68 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; 69 return CGM.CreateRuntimeFunction( 70 llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend", 71 llvm::AttributeList::get(CGM.getLLVMContext(), 72 llvm::AttributeList::FunctionIndex, 73 llvm::Attribute::NonLazyBind)); 74 } 75 76 /// void objc_msgSend_stret (id, SEL, ...) 77 /// 78 /// The messenger used when the return value is an aggregate returned 79 /// by indirect reference in the first argument, and therefore the 80 /// self and selector parameters are shifted over by one. 81 llvm::FunctionCallee getMessageSendStretFn() const { 82 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; 83 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, 84 params, true), 85 "objc_msgSend_stret"); 86 } 87 88 /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...) 89 /// 90 /// The messenger used when the return value is returned on the x87 91 /// floating-point stack; without a special entrypoint, the nil case 92 /// would be unbalanced. 93 llvm::FunctionCallee getMessageSendFpretFn() const { 94 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; 95 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy, 96 params, true), 97 "objc_msgSend_fpret"); 98 } 99 100 /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...) 101 /// 102 /// The messenger used when the return value is returned in two values on the 103 /// x87 floating point stack; without a special entrypoint, the nil case 104 /// would be unbalanced. Only used on 64-bit X86. 105 llvm::FunctionCallee getMessageSendFp2retFn() const { 106 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; 107 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext); 108 llvm::Type *resultType = 109 llvm::StructType::get(longDoubleType, longDoubleType); 110 111 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType, 112 params, true), 113 "objc_msgSend_fp2ret"); 114 } 115 116 /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...) 117 /// 118 /// The messenger used for super calls, which have different dispatch 119 /// semantics. The class passed is the superclass of the current 120 /// class. 121 llvm::FunctionCallee getMessageSendSuperFn() const { 122 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy }; 123 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 124 params, true), 125 "objc_msgSendSuper"); 126 } 127 128 /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...) 129 /// 130 /// A slightly different messenger used for super calls. The class 131 /// passed is the current class. 132 llvm::FunctionCallee getMessageSendSuperFn2() const { 133 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy }; 134 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 135 params, true), 136 "objc_msgSendSuper2"); 137 } 138 139 /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super, 140 /// SEL op, ...) 141 /// 142 /// The messenger used for super calls which return an aggregate indirectly. 143 llvm::FunctionCallee getMessageSendSuperStretFn() const { 144 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy }; 145 return CGM.CreateRuntimeFunction( 146 llvm::FunctionType::get(CGM.VoidTy, params, true), 147 "objc_msgSendSuper_stret"); 148 } 149 150 /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super, 151 /// SEL op, ...) 152 /// 153 /// objc_msgSendSuper_stret with the super2 semantics. 154 llvm::FunctionCallee getMessageSendSuperStretFn2() const { 155 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy }; 156 return CGM.CreateRuntimeFunction( 157 llvm::FunctionType::get(CGM.VoidTy, params, true), 158 "objc_msgSendSuper2_stret"); 159 } 160 161 llvm::FunctionCallee getMessageSendSuperFpretFn() const { 162 // There is no objc_msgSendSuper_fpret? How can that work? 163 return getMessageSendSuperFn(); 164 } 165 166 llvm::FunctionCallee getMessageSendSuperFpretFn2() const { 167 // There is no objc_msgSendSuper_fpret? How can that work? 168 return getMessageSendSuperFn2(); 169 } 170 171 protected: 172 CodeGen::CodeGenModule &CGM; 173 174 public: 175 llvm::IntegerType *ShortTy, *IntTy, *LongTy; 176 llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy; 177 llvm::Type *IvarOffsetVarTy; 178 179 /// ObjectPtrTy - LLVM type for object handles (typeof(id)) 180 llvm::PointerType *ObjectPtrTy; 181 182 /// PtrObjectPtrTy - LLVM type for id * 183 llvm::PointerType *PtrObjectPtrTy; 184 185 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL)) 186 llvm::PointerType *SelectorPtrTy; 187 188 private: 189 /// ProtocolPtrTy - LLVM type for external protocol handles 190 /// (typeof(Protocol)) 191 llvm::Type *ExternalProtocolPtrTy; 192 193 public: 194 llvm::Type *getExternalProtocolPtrTy() { 195 if (!ExternalProtocolPtrTy) { 196 // FIXME: It would be nice to unify this with the opaque type, so that the 197 // IR comes out a bit cleaner. 198 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 199 ASTContext &Ctx = CGM.getContext(); 200 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType()); 201 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T); 202 } 203 204 return ExternalProtocolPtrTy; 205 } 206 207 // SuperCTy - clang type for struct objc_super. 208 QualType SuperCTy; 209 // SuperPtrCTy - clang type for struct objc_super *. 210 QualType SuperPtrCTy; 211 212 /// SuperTy - LLVM type for struct objc_super. 213 llvm::StructType *SuperTy; 214 /// SuperPtrTy - LLVM type for struct objc_super *. 215 llvm::PointerType *SuperPtrTy; 216 217 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t 218 /// in GCC parlance). 219 llvm::StructType *PropertyTy; 220 221 /// PropertyListTy - LLVM type for struct objc_property_list 222 /// (_prop_list_t in GCC parlance). 223 llvm::StructType *PropertyListTy; 224 /// PropertyListPtrTy - LLVM type for struct objc_property_list*. 225 llvm::PointerType *PropertyListPtrTy; 226 227 // MethodTy - LLVM type for struct objc_method. 228 llvm::StructType *MethodTy; 229 230 /// CacheTy - LLVM type for struct objc_cache. 231 llvm::Type *CacheTy; 232 /// CachePtrTy - LLVM type for struct objc_cache *. 233 llvm::PointerType *CachePtrTy; 234 235 llvm::FunctionCallee getGetPropertyFn() { 236 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 237 ASTContext &Ctx = CGM.getContext(); 238 // id objc_getProperty (id, SEL, ptrdiff_t, bool) 239 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); 240 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); 241 CanQualType Params[] = { 242 IdType, SelType, 243 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy}; 244 llvm::FunctionType *FTy = 245 Types.GetFunctionType( 246 Types.arrangeBuiltinFunctionDeclaration(IdType, Params)); 247 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty"); 248 } 249 250 llvm::FunctionCallee getSetPropertyFn() { 251 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 252 ASTContext &Ctx = CGM.getContext(); 253 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool) 254 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); 255 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); 256 CanQualType Params[] = { 257 IdType, 258 SelType, 259 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), 260 IdType, 261 Ctx.BoolTy, 262 Ctx.BoolTy}; 263 llvm::FunctionType *FTy = 264 Types.GetFunctionType( 265 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); 266 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty"); 267 } 268 269 llvm::FunctionCallee getOptimizedSetPropertyFn(bool atomic, bool copy) { 270 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 271 ASTContext &Ctx = CGM.getContext(); 272 // void objc_setProperty_atomic(id self, SEL _cmd, 273 // id newValue, ptrdiff_t offset); 274 // void objc_setProperty_nonatomic(id self, SEL _cmd, 275 // id newValue, ptrdiff_t offset); 276 // void objc_setProperty_atomic_copy(id self, SEL _cmd, 277 // id newValue, ptrdiff_t offset); 278 // void objc_setProperty_nonatomic_copy(id self, SEL _cmd, 279 // id newValue, ptrdiff_t offset); 280 281 SmallVector<CanQualType,4> Params; 282 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); 283 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); 284 Params.push_back(IdType); 285 Params.push_back(SelType); 286 Params.push_back(IdType); 287 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified()); 288 llvm::FunctionType *FTy = 289 Types.GetFunctionType( 290 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); 291 const char *name; 292 if (atomic && copy) 293 name = "objc_setProperty_atomic_copy"; 294 else if (atomic && !copy) 295 name = "objc_setProperty_atomic"; 296 else if (!atomic && copy) 297 name = "objc_setProperty_nonatomic_copy"; 298 else 299 name = "objc_setProperty_nonatomic"; 300 301 return CGM.CreateRuntimeFunction(FTy, name); 302 } 303 304 llvm::FunctionCallee getCopyStructFn() { 305 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 306 ASTContext &Ctx = CGM.getContext(); 307 // void objc_copyStruct (void *, const void *, size_t, bool, bool) 308 SmallVector<CanQualType,5> Params; 309 Params.push_back(Ctx.VoidPtrTy); 310 Params.push_back(Ctx.VoidPtrTy); 311 Params.push_back(Ctx.getSizeType()); 312 Params.push_back(Ctx.BoolTy); 313 Params.push_back(Ctx.BoolTy); 314 llvm::FunctionType *FTy = 315 Types.GetFunctionType( 316 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); 317 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct"); 318 } 319 320 /// This routine declares and returns address of: 321 /// void objc_copyCppObjectAtomic( 322 /// void *dest, const void *src, 323 /// void (*copyHelper) (void *dest, const void *source)); 324 llvm::FunctionCallee getCppAtomicObjectFunction() { 325 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 326 ASTContext &Ctx = CGM.getContext(); 327 /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper); 328 SmallVector<CanQualType,3> Params; 329 Params.push_back(Ctx.VoidPtrTy); 330 Params.push_back(Ctx.VoidPtrTy); 331 Params.push_back(Ctx.VoidPtrTy); 332 llvm::FunctionType *FTy = 333 Types.GetFunctionType( 334 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); 335 return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic"); 336 } 337 338 llvm::FunctionCallee getEnumerationMutationFn() { 339 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 340 ASTContext &Ctx = CGM.getContext(); 341 // void objc_enumerationMutation (id) 342 SmallVector<CanQualType,1> Params; 343 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType())); 344 llvm::FunctionType *FTy = 345 Types.GetFunctionType( 346 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); 347 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation"); 348 } 349 350 llvm::FunctionCallee getLookUpClassFn() { 351 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 352 ASTContext &Ctx = CGM.getContext(); 353 // Class objc_lookUpClass (const char *) 354 SmallVector<CanQualType,1> Params; 355 Params.push_back( 356 Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst()))); 357 llvm::FunctionType *FTy = 358 Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration( 359 Ctx.getCanonicalType(Ctx.getObjCClassType()), 360 Params)); 361 return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass"); 362 } 363 364 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function. 365 llvm::FunctionCallee getGcReadWeakFn() { 366 // id objc_read_weak (id *) 367 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() }; 368 llvm::FunctionType *FTy = 369 llvm::FunctionType::get(ObjectPtrTy, args, false); 370 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak"); 371 } 372 373 /// GcAssignWeakFn -- LLVM objc_assign_weak function. 374 llvm::FunctionCallee getGcAssignWeakFn() { 375 // id objc_assign_weak (id, id *) 376 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; 377 llvm::FunctionType *FTy = 378 llvm::FunctionType::get(ObjectPtrTy, args, false); 379 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak"); 380 } 381 382 /// GcAssignGlobalFn -- LLVM objc_assign_global function. 383 llvm::FunctionCallee getGcAssignGlobalFn() { 384 // id objc_assign_global(id, id *) 385 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; 386 llvm::FunctionType *FTy = 387 llvm::FunctionType::get(ObjectPtrTy, args, false); 388 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global"); 389 } 390 391 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function. 392 llvm::FunctionCallee getGcAssignThreadLocalFn() { 393 // id objc_assign_threadlocal(id src, id * dest) 394 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; 395 llvm::FunctionType *FTy = 396 llvm::FunctionType::get(ObjectPtrTy, args, false); 397 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal"); 398 } 399 400 /// GcAssignIvarFn -- LLVM objc_assign_ivar function. 401 llvm::FunctionCallee getGcAssignIvarFn() { 402 // id objc_assign_ivar(id, id *, ptrdiff_t) 403 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(), 404 CGM.PtrDiffTy }; 405 llvm::FunctionType *FTy = 406 llvm::FunctionType::get(ObjectPtrTy, args, false); 407 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar"); 408 } 409 410 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function. 411 llvm::FunctionCallee GcMemmoveCollectableFn() { 412 // void *objc_memmove_collectable(void *dst, const void *src, size_t size) 413 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy }; 414 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false); 415 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable"); 416 } 417 418 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function. 419 llvm::FunctionCallee getGcAssignStrongCastFn() { 420 // id objc_assign_strongCast(id, id *) 421 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; 422 llvm::FunctionType *FTy = 423 llvm::FunctionType::get(ObjectPtrTy, args, false); 424 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast"); 425 } 426 427 /// ExceptionThrowFn - LLVM objc_exception_throw function. 428 llvm::FunctionCallee getExceptionThrowFn() { 429 // void objc_exception_throw(id) 430 llvm::Type *args[] = { ObjectPtrTy }; 431 llvm::FunctionType *FTy = 432 llvm::FunctionType::get(CGM.VoidTy, args, false); 433 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw"); 434 } 435 436 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function. 437 llvm::FunctionCallee getExceptionRethrowFn() { 438 // void objc_exception_rethrow(void) 439 llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false); 440 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow"); 441 } 442 443 /// SyncEnterFn - LLVM object_sync_enter function. 444 llvm::FunctionCallee getSyncEnterFn() { 445 // int objc_sync_enter (id) 446 llvm::Type *args[] = { ObjectPtrTy }; 447 llvm::FunctionType *FTy = 448 llvm::FunctionType::get(CGM.IntTy, args, false); 449 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter"); 450 } 451 452 /// SyncExitFn - LLVM object_sync_exit function. 453 llvm::FunctionCallee getSyncExitFn() { 454 // int objc_sync_exit (id) 455 llvm::Type *args[] = { ObjectPtrTy }; 456 llvm::FunctionType *FTy = 457 llvm::FunctionType::get(CGM.IntTy, args, false); 458 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit"); 459 } 460 461 llvm::FunctionCallee getSendFn(bool IsSuper) const { 462 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn(); 463 } 464 465 llvm::FunctionCallee getSendFn2(bool IsSuper) const { 466 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn(); 467 } 468 469 llvm::FunctionCallee getSendStretFn(bool IsSuper) const { 470 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn(); 471 } 472 473 llvm::FunctionCallee getSendStretFn2(bool IsSuper) const { 474 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn(); 475 } 476 477 llvm::FunctionCallee getSendFpretFn(bool IsSuper) const { 478 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn(); 479 } 480 481 llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const { 482 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn(); 483 } 484 485 llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const { 486 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn(); 487 } 488 489 llvm::FunctionCallee getSendFp2RetFn2(bool IsSuper) const { 490 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn(); 491 } 492 493 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm); 494 }; 495 496 /// ObjCTypesHelper - Helper class that encapsulates lazy 497 /// construction of varies types used during ObjC generation. 498 class ObjCTypesHelper : public ObjCCommonTypesHelper { 499 public: 500 /// SymtabTy - LLVM type for struct objc_symtab. 501 llvm::StructType *SymtabTy; 502 /// SymtabPtrTy - LLVM type for struct objc_symtab *. 503 llvm::PointerType *SymtabPtrTy; 504 /// ModuleTy - LLVM type for struct objc_module. 505 llvm::StructType *ModuleTy; 506 507 /// ProtocolTy - LLVM type for struct objc_protocol. 508 llvm::StructType *ProtocolTy; 509 /// ProtocolPtrTy - LLVM type for struct objc_protocol *. 510 llvm::PointerType *ProtocolPtrTy; 511 /// ProtocolExtensionTy - LLVM type for struct 512 /// objc_protocol_extension. 513 llvm::StructType *ProtocolExtensionTy; 514 /// ProtocolExtensionTy - LLVM type for struct 515 /// objc_protocol_extension *. 516 llvm::PointerType *ProtocolExtensionPtrTy; 517 /// MethodDescriptionTy - LLVM type for struct 518 /// objc_method_description. 519 llvm::StructType *MethodDescriptionTy; 520 /// MethodDescriptionListTy - LLVM type for struct 521 /// objc_method_description_list. 522 llvm::StructType *MethodDescriptionListTy; 523 /// MethodDescriptionListPtrTy - LLVM type for struct 524 /// objc_method_description_list *. 525 llvm::PointerType *MethodDescriptionListPtrTy; 526 /// ProtocolListTy - LLVM type for struct objc_property_list. 527 llvm::StructType *ProtocolListTy; 528 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*. 529 llvm::PointerType *ProtocolListPtrTy; 530 /// CategoryTy - LLVM type for struct objc_category. 531 llvm::StructType *CategoryTy; 532 /// ClassTy - LLVM type for struct objc_class. 533 llvm::StructType *ClassTy; 534 /// ClassPtrTy - LLVM type for struct objc_class *. 535 llvm::PointerType *ClassPtrTy; 536 /// ClassExtensionTy - LLVM type for struct objc_class_ext. 537 llvm::StructType *ClassExtensionTy; 538 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *. 539 llvm::PointerType *ClassExtensionPtrTy; 540 // IvarTy - LLVM type for struct objc_ivar. 541 llvm::StructType *IvarTy; 542 /// IvarListTy - LLVM type for struct objc_ivar_list. 543 llvm::StructType *IvarListTy; 544 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *. 545 llvm::PointerType *IvarListPtrTy; 546 /// MethodListTy - LLVM type for struct objc_method_list. 547 llvm::StructType *MethodListTy; 548 /// MethodListPtrTy - LLVM type for struct objc_method_list *. 549 llvm::PointerType *MethodListPtrTy; 550 551 /// ExceptionDataTy - LLVM type for struct _objc_exception_data. 552 llvm::StructType *ExceptionDataTy; 553 554 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function. 555 llvm::FunctionCallee getExceptionTryEnterFn() { 556 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; 557 return CGM.CreateRuntimeFunction( 558 llvm::FunctionType::get(CGM.VoidTy, params, false), 559 "objc_exception_try_enter"); 560 } 561 562 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function. 563 llvm::FunctionCallee getExceptionTryExitFn() { 564 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; 565 return CGM.CreateRuntimeFunction( 566 llvm::FunctionType::get(CGM.VoidTy, params, false), 567 "objc_exception_try_exit"); 568 } 569 570 /// ExceptionExtractFn - LLVM objc_exception_extract function. 571 llvm::FunctionCallee getExceptionExtractFn() { 572 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; 573 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 574 params, false), 575 "objc_exception_extract"); 576 } 577 578 /// ExceptionMatchFn - LLVM objc_exception_match function. 579 llvm::FunctionCallee getExceptionMatchFn() { 580 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy }; 581 return CGM.CreateRuntimeFunction( 582 llvm::FunctionType::get(CGM.Int32Ty, params, false), 583 "objc_exception_match"); 584 } 585 586 /// SetJmpFn - LLVM _setjmp function. 587 llvm::FunctionCallee getSetJmpFn() { 588 // This is specifically the prototype for x86. 589 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() }; 590 return CGM.CreateRuntimeFunction( 591 llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp", 592 llvm::AttributeList::get(CGM.getLLVMContext(), 593 llvm::AttributeList::FunctionIndex, 594 llvm::Attribute::NonLazyBind)); 595 } 596 597 public: 598 ObjCTypesHelper(CodeGen::CodeGenModule &cgm); 599 }; 600 601 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's 602 /// modern abi 603 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper { 604 public: 605 // MethodListnfABITy - LLVM for struct _method_list_t 606 llvm::StructType *MethodListnfABITy; 607 608 // MethodListnfABIPtrTy - LLVM for struct _method_list_t* 609 llvm::PointerType *MethodListnfABIPtrTy; 610 611 // ProtocolnfABITy = LLVM for struct _protocol_t 612 llvm::StructType *ProtocolnfABITy; 613 614 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t* 615 llvm::PointerType *ProtocolnfABIPtrTy; 616 617 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list 618 llvm::StructType *ProtocolListnfABITy; 619 620 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list* 621 llvm::PointerType *ProtocolListnfABIPtrTy; 622 623 // ClassnfABITy - LLVM for struct _class_t 624 llvm::StructType *ClassnfABITy; 625 626 // ClassnfABIPtrTy - LLVM for struct _class_t* 627 llvm::PointerType *ClassnfABIPtrTy; 628 629 // IvarnfABITy - LLVM for struct _ivar_t 630 llvm::StructType *IvarnfABITy; 631 632 // IvarListnfABITy - LLVM for struct _ivar_list_t 633 llvm::StructType *IvarListnfABITy; 634 635 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t* 636 llvm::PointerType *IvarListnfABIPtrTy; 637 638 // ClassRonfABITy - LLVM for struct _class_ro_t 639 llvm::StructType *ClassRonfABITy; 640 641 // ImpnfABITy - LLVM for id (*)(id, SEL, ...) 642 llvm::PointerType *ImpnfABITy; 643 644 // CategorynfABITy - LLVM for struct _category_t 645 llvm::StructType *CategorynfABITy; 646 647 // New types for nonfragile abi messaging. 648 649 // MessageRefTy - LLVM for: 650 // struct _message_ref_t { 651 // IMP messenger; 652 // SEL name; 653 // }; 654 llvm::StructType *MessageRefTy; 655 // MessageRefCTy - clang type for struct _message_ref_t 656 QualType MessageRefCTy; 657 658 // MessageRefPtrTy - LLVM for struct _message_ref_t* 659 llvm::Type *MessageRefPtrTy; 660 // MessageRefCPtrTy - clang type for struct _message_ref_t* 661 QualType MessageRefCPtrTy; 662 663 // SuperMessageRefTy - LLVM for: 664 // struct _super_message_ref_t { 665 // SUPER_IMP messenger; 666 // SEL name; 667 // }; 668 llvm::StructType *SuperMessageRefTy; 669 670 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t* 671 llvm::PointerType *SuperMessageRefPtrTy; 672 673 llvm::FunctionCallee getMessageSendFixupFn() { 674 // id objc_msgSend_fixup(id, struct message_ref_t*, ...) 675 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; 676 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 677 params, true), 678 "objc_msgSend_fixup"); 679 } 680 681 llvm::FunctionCallee getMessageSendFpretFixupFn() { 682 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...) 683 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; 684 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 685 params, true), 686 "objc_msgSend_fpret_fixup"); 687 } 688 689 llvm::FunctionCallee getMessageSendStretFixupFn() { 690 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...) 691 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; 692 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 693 params, true), 694 "objc_msgSend_stret_fixup"); 695 } 696 697 llvm::FunctionCallee getMessageSendSuper2FixupFn() { 698 // id objc_msgSendSuper2_fixup (struct objc_super *, 699 // struct _super_message_ref_t*, ...) 700 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy }; 701 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 702 params, true), 703 "objc_msgSendSuper2_fixup"); 704 } 705 706 llvm::FunctionCallee getMessageSendSuper2StretFixupFn() { 707 // id objc_msgSendSuper2_stret_fixup(struct objc_super *, 708 // struct _super_message_ref_t*, ...) 709 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy }; 710 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 711 params, true), 712 "objc_msgSendSuper2_stret_fixup"); 713 } 714 715 llvm::FunctionCallee getObjCEndCatchFn() { 716 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false), 717 "objc_end_catch"); 718 } 719 720 llvm::FunctionCallee getObjCBeginCatchFn() { 721 llvm::Type *params[] = { Int8PtrTy }; 722 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy, 723 params, false), 724 "objc_begin_catch"); 725 } 726 727 /// Class objc_loadClassref (void *) 728 /// 729 /// Loads from a classref. For Objective-C stub classes, this invokes the 730 /// initialization callback stored inside the stub. For all other classes 731 /// this simply dereferences the pointer. 732 llvm::FunctionCallee getLoadClassrefFn() const { 733 // Add the non-lazy-bind attribute, since objc_loadClassref is likely to 734 // be called a lot. 735 // 736 // Also it is safe to make it readnone, since we never load or store the 737 // classref except by calling this function. 738 llvm::Type *params[] = { Int8PtrPtrTy }; 739 llvm::FunctionCallee F = CGM.CreateRuntimeFunction( 740 llvm::FunctionType::get(ClassnfABIPtrTy, params, false), 741 "objc_loadClassref", 742 llvm::AttributeList::get(CGM.getLLVMContext(), 743 llvm::AttributeList::FunctionIndex, 744 {llvm::Attribute::NonLazyBind, 745 llvm::Attribute::ReadNone, 746 llvm::Attribute::NoUnwind})); 747 if (!CGM.getTriple().isOSBinFormatCOFF()) 748 cast<llvm::Function>(F.getCallee())->setLinkage( 749 llvm::Function::ExternalWeakLinkage); 750 751 return F; 752 } 753 754 llvm::StructType *EHTypeTy; 755 llvm::Type *EHTypePtrTy; 756 757 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm); 758 }; 759 760 enum class ObjCLabelType { 761 ClassName, 762 MethodVarName, 763 MethodVarType, 764 PropertyName, 765 }; 766 767 class CGObjCCommonMac : public CodeGen::CGObjCRuntime { 768 public: 769 class SKIP_SCAN { 770 public: 771 unsigned skip; 772 unsigned scan; 773 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0) 774 : skip(_skip), scan(_scan) {} 775 }; 776 777 /// opcode for captured block variables layout 'instructions'. 778 /// In the following descriptions, 'I' is the value of the immediate field. 779 /// (field following the opcode). 780 /// 781 enum BLOCK_LAYOUT_OPCODE { 782 /// An operator which affects how the following layout should be 783 /// interpreted. 784 /// I == 0: Halt interpretation and treat everything else as 785 /// a non-pointer. Note that this instruction is equal 786 /// to '\0'. 787 /// I != 0: Currently unused. 788 BLOCK_LAYOUT_OPERATOR = 0, 789 790 /// The next I+1 bytes do not contain a value of object pointer type. 791 /// Note that this can leave the stream unaligned, meaning that 792 /// subsequent word-size instructions do not begin at a multiple of 793 /// the pointer size. 794 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1, 795 796 /// The next I+1 words do not contain a value of object pointer type. 797 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for 798 /// when the required skip quantity is a multiple of the pointer size. 799 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2, 800 801 /// The next I+1 words are __strong pointers to Objective-C 802 /// objects or blocks. 803 BLOCK_LAYOUT_STRONG = 3, 804 805 /// The next I+1 words are pointers to __block variables. 806 BLOCK_LAYOUT_BYREF = 4, 807 808 /// The next I+1 words are __weak pointers to Objective-C 809 /// objects or blocks. 810 BLOCK_LAYOUT_WEAK = 5, 811 812 /// The next I+1 words are __unsafe_unretained pointers to 813 /// Objective-C objects or blocks. 814 BLOCK_LAYOUT_UNRETAINED = 6 815 816 /// The next I+1 words are block or object pointers with some 817 /// as-yet-unspecified ownership semantics. If we add more 818 /// flavors of ownership semantics, values will be taken from 819 /// this range. 820 /// 821 /// This is included so that older tools can at least continue 822 /// processing the layout past such things. 823 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10, 824 825 /// All other opcodes are reserved. Halt interpretation and 826 /// treat everything else as opaque. 827 }; 828 829 class RUN_SKIP { 830 public: 831 enum BLOCK_LAYOUT_OPCODE opcode; 832 CharUnits block_var_bytepos; 833 CharUnits block_var_size; 834 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR, 835 CharUnits BytePos = CharUnits::Zero(), 836 CharUnits Size = CharUnits::Zero()) 837 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {} 838 839 // Allow sorting based on byte pos. 840 bool operator<(const RUN_SKIP &b) const { 841 return block_var_bytepos < b.block_var_bytepos; 842 } 843 }; 844 845 protected: 846 llvm::LLVMContext &VMContext; 847 // FIXME! May not be needing this after all. 848 unsigned ObjCABI; 849 850 // arc/mrr layout of captured block literal variables. 851 SmallVector<RUN_SKIP, 16> RunSkipBlockVars; 852 853 /// LazySymbols - Symbols to generate a lazy reference for. See 854 /// DefinedSymbols and FinishModule(). 855 llvm::SetVector<IdentifierInfo*> LazySymbols; 856 857 /// DefinedSymbols - External symbols which are defined by this 858 /// module. The symbols in this list and LazySymbols are used to add 859 /// special linker symbols which ensure that Objective-C modules are 860 /// linked properly. 861 llvm::SetVector<IdentifierInfo*> DefinedSymbols; 862 863 /// ClassNames - uniqued class names. 864 llvm::StringMap<llvm::GlobalVariable*> ClassNames; 865 866 /// MethodVarNames - uniqued method variable names. 867 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames; 868 869 /// DefinedCategoryNames - list of category names in form Class_Category. 870 llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames; 871 872 /// MethodVarTypes - uniqued method type signatures. We have to use 873 /// a StringMap here because have no other unique reference. 874 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes; 875 876 /// MethodDefinitions - map of methods which have been defined in 877 /// this translation unit. 878 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions; 879 880 /// DirectMethodDefinitions - map of direct methods which have been defined in 881 /// this translation unit. 882 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> DirectMethodDefinitions; 883 884 /// PropertyNames - uniqued method variable names. 885 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames; 886 887 /// ClassReferences - uniqued class references. 888 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences; 889 890 /// SelectorReferences - uniqued selector references. 891 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences; 892 893 /// Protocols - Protocols for which an objc_protocol structure has 894 /// been emitted. Forward declarations are handled by creating an 895 /// empty structure whose initializer is filled in when/if defined. 896 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols; 897 898 /// DefinedProtocols - Protocols which have actually been 899 /// defined. We should not need this, see FIXME in GenerateProtocol. 900 llvm::DenseSet<IdentifierInfo*> DefinedProtocols; 901 902 /// DefinedClasses - List of defined classes. 903 SmallVector<llvm::GlobalValue*, 16> DefinedClasses; 904 905 /// ImplementedClasses - List of @implemented classes. 906 SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses; 907 908 /// DefinedNonLazyClasses - List of defined "non-lazy" classes. 909 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses; 910 911 /// DefinedCategories - List of defined categories. 912 SmallVector<llvm::GlobalValue*, 16> DefinedCategories; 913 914 /// DefinedStubCategories - List of defined categories on class stubs. 915 SmallVector<llvm::GlobalValue*, 16> DefinedStubCategories; 916 917 /// DefinedNonLazyCategories - List of defined "non-lazy" categories. 918 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories; 919 920 /// Cached reference to the class for constant strings. This value has type 921 /// int * but is actually an Obj-C class pointer. 922 llvm::WeakTrackingVH ConstantStringClassRef; 923 924 /// The LLVM type corresponding to NSConstantString. 925 llvm::StructType *NSConstantStringType = nullptr; 926 927 llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap; 928 929 /// GetMethodVarName - Return a unique constant for the given 930 /// selector's name. The return value has type char *. 931 llvm::Constant *GetMethodVarName(Selector Sel); 932 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident); 933 934 /// GetMethodVarType - Return a unique constant for the given 935 /// method's type encoding string. The return value has type char *. 936 937 // FIXME: This is a horrible name. 938 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D, 939 bool Extended = false); 940 llvm::Constant *GetMethodVarType(const FieldDecl *D); 941 942 /// GetPropertyName - Return a unique constant for the given 943 /// name. The return value has type char *. 944 llvm::Constant *GetPropertyName(IdentifierInfo *Ident); 945 946 // FIXME: This can be dropped once string functions are unified. 947 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD, 948 const Decl *Container); 949 950 /// GetClassName - Return a unique constant for the given selector's 951 /// runtime name (which may change via use of objc_runtime_name attribute on 952 /// class or protocol definition. The return value has type char *. 953 llvm::Constant *GetClassName(StringRef RuntimeName); 954 955 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD); 956 957 /// BuildIvarLayout - Builds ivar layout bitmap for the class 958 /// implementation for the __strong or __weak case. 959 /// 960 /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there 961 /// are any weak ivars defined directly in the class. Meaningless unless 962 /// building a weak layout. Does not guarantee that the layout will 963 /// actually have any entries, because the ivar might be under-aligned. 964 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI, 965 CharUnits beginOffset, 966 CharUnits endOffset, 967 bool forStrongLayout, 968 bool hasMRCWeakIvars); 969 970 llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI, 971 CharUnits beginOffset, 972 CharUnits endOffset) { 973 return BuildIvarLayout(OI, beginOffset, endOffset, true, false); 974 } 975 976 llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI, 977 CharUnits beginOffset, 978 CharUnits endOffset, 979 bool hasMRCWeakIvars) { 980 return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars); 981 } 982 983 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout); 984 985 void UpdateRunSkipBlockVars(bool IsByref, 986 Qualifiers::ObjCLifetime LifeTime, 987 CharUnits FieldOffset, 988 CharUnits FieldSize); 989 990 void BuildRCBlockVarRecordLayout(const RecordType *RT, 991 CharUnits BytePos, bool &HasUnion, 992 bool ByrefLayout=false); 993 994 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout, 995 const RecordDecl *RD, 996 ArrayRef<const FieldDecl*> RecFields, 997 CharUnits BytePos, bool &HasUnion, 998 bool ByrefLayout); 999 1000 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout); 1001 1002 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout); 1003 1004 /// GetIvarLayoutName - Returns a unique constant for the given 1005 /// ivar layout bitmap. 1006 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident, 1007 const ObjCCommonTypesHelper &ObjCTypes); 1008 1009 /// EmitPropertyList - Emit the given property list. The return 1010 /// value has type PropertyListPtrTy. 1011 llvm::Constant *EmitPropertyList(Twine Name, 1012 const Decl *Container, 1013 const ObjCContainerDecl *OCD, 1014 const ObjCCommonTypesHelper &ObjCTypes, 1015 bool IsClassProperty); 1016 1017 /// EmitProtocolMethodTypes - Generate the array of extended method type 1018 /// strings. The return value has type Int8PtrPtrTy. 1019 llvm::Constant *EmitProtocolMethodTypes(Twine Name, 1020 ArrayRef<llvm::Constant*> MethodTypes, 1021 const ObjCCommonTypesHelper &ObjCTypes); 1022 1023 /// GetProtocolRef - Return a reference to the internal protocol 1024 /// description, creating an empty one if it has not been 1025 /// defined. The return value has type ProtocolPtrTy. 1026 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD); 1027 1028 /// Return a reference to the given Class using runtime calls rather than 1029 /// by a symbol reference. 1030 llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF, 1031 const ObjCInterfaceDecl *ID, 1032 ObjCCommonTypesHelper &ObjCTypes); 1033 1034 std::string GetSectionName(StringRef Section, StringRef MachOAttributes); 1035 1036 public: 1037 /// CreateMetadataVar - Create a global variable with internal 1038 /// linkage for use by the Objective-C runtime. 1039 /// 1040 /// This is a convenience wrapper which not only creates the 1041 /// variable, but also sets the section and alignment and adds the 1042 /// global to the "llvm.used" list. 1043 /// 1044 /// \param Name - The variable name. 1045 /// \param Init - The variable initializer; this is also used to 1046 /// define the type of the variable. 1047 /// \param Section - The section the variable should go into, or empty. 1048 /// \param Align - The alignment for the variable, or 0. 1049 /// \param AddToUsed - Whether the variable should be added to 1050 /// "llvm.used". 1051 llvm::GlobalVariable *CreateMetadataVar(Twine Name, 1052 ConstantStructBuilder &Init, 1053 StringRef Section, CharUnits Align, 1054 bool AddToUsed); 1055 llvm::GlobalVariable *CreateMetadataVar(Twine Name, 1056 llvm::Constant *Init, 1057 StringRef Section, CharUnits Align, 1058 bool AddToUsed); 1059 1060 llvm::GlobalVariable *CreateCStringLiteral(StringRef Name, 1061 ObjCLabelType LabelType, 1062 bool ForceNonFragileABI = false, 1063 bool NullTerminate = true); 1064 1065 protected: 1066 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF, 1067 ReturnValueSlot Return, 1068 QualType ResultType, 1069 Selector Sel, 1070 llvm::Value *Arg0, 1071 QualType Arg0Ty, 1072 bool IsSuper, 1073 const CallArgList &CallArgs, 1074 const ObjCMethodDecl *OMD, 1075 const ObjCInterfaceDecl *ClassReceiver, 1076 const ObjCCommonTypesHelper &ObjCTypes); 1077 1078 /// EmitImageInfo - Emit the image info marker used to encode some module 1079 /// level information. 1080 void EmitImageInfo(); 1081 1082 public: 1083 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) 1084 : CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) {} 1085 1086 bool isNonFragileABI() const { 1087 return ObjCABI == 2; 1088 } 1089 1090 ConstantAddress GenerateConstantString(const StringLiteral *SL) override; 1091 ConstantAddress GenerateConstantNSString(const StringLiteral *SL); 1092 1093 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, 1094 const ObjCContainerDecl *CD=nullptr) override; 1095 1096 llvm::Function *GenerateDirectMethod(const ObjCMethodDecl *OMD, 1097 const ObjCContainerDecl *CD); 1098 1099 void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn, 1100 const ObjCMethodDecl *OMD, 1101 const ObjCContainerDecl *CD) override; 1102 1103 void GenerateProtocol(const ObjCProtocolDecl *PD) override; 1104 1105 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 1106 /// object for the given declaration, emitting it if needed. These 1107 /// forward references will be filled in with empty bodies if no 1108 /// definition is seen. The return value has type ProtocolPtrTy. 1109 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0; 1110 1111 virtual llvm::Constant *getNSConstantStringClassRef() = 0; 1112 1113 llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, 1114 const CGBlockInfo &blockInfo) override; 1115 llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, 1116 const CGBlockInfo &blockInfo) override; 1117 std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM, 1118 const CGBlockInfo &blockInfo) override; 1119 1120 llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM, 1121 QualType T) override; 1122 1123 private: 1124 void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo); 1125 }; 1126 1127 namespace { 1128 1129 enum class MethodListType { 1130 CategoryInstanceMethods, 1131 CategoryClassMethods, 1132 InstanceMethods, 1133 ClassMethods, 1134 ProtocolInstanceMethods, 1135 ProtocolClassMethods, 1136 OptionalProtocolInstanceMethods, 1137 OptionalProtocolClassMethods, 1138 }; 1139 1140 /// A convenience class for splitting the methods of a protocol into 1141 /// the four interesting groups. 1142 class ProtocolMethodLists { 1143 public: 1144 enum Kind { 1145 RequiredInstanceMethods, 1146 RequiredClassMethods, 1147 OptionalInstanceMethods, 1148 OptionalClassMethods 1149 }; 1150 enum { 1151 NumProtocolMethodLists = 4 1152 }; 1153 1154 static MethodListType getMethodListKind(Kind kind) { 1155 switch (kind) { 1156 case RequiredInstanceMethods: 1157 return MethodListType::ProtocolInstanceMethods; 1158 case RequiredClassMethods: 1159 return MethodListType::ProtocolClassMethods; 1160 case OptionalInstanceMethods: 1161 return MethodListType::OptionalProtocolInstanceMethods; 1162 case OptionalClassMethods: 1163 return MethodListType::OptionalProtocolClassMethods; 1164 } 1165 llvm_unreachable("bad kind"); 1166 } 1167 1168 SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists]; 1169 1170 static ProtocolMethodLists get(const ObjCProtocolDecl *PD) { 1171 ProtocolMethodLists result; 1172 1173 for (auto MD : PD->methods()) { 1174 size_t index = (2 * size_t(MD->isOptional())) 1175 + (size_t(MD->isClassMethod())); 1176 result.Methods[index].push_back(MD); 1177 } 1178 1179 return result; 1180 } 1181 1182 template <class Self> 1183 SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const { 1184 // In both ABIs, the method types list is parallel with the 1185 // concatenation of the methods arrays in the following order: 1186 // instance methods 1187 // class methods 1188 // optional instance methods 1189 // optional class methods 1190 SmallVector<llvm::Constant*, 8> result; 1191 1192 // Methods is already in the correct order for both ABIs. 1193 for (auto &list : Methods) { 1194 for (auto MD : list) { 1195 result.push_back(self->GetMethodVarType(MD, true)); 1196 } 1197 } 1198 1199 return result; 1200 } 1201 1202 template <class Self> 1203 llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD, 1204 Kind kind) const { 1205 return self->emitMethodList(PD->getObjCRuntimeNameAsString(), 1206 getMethodListKind(kind), Methods[kind]); 1207 } 1208 }; 1209 1210 } // end anonymous namespace 1211 1212 class CGObjCMac : public CGObjCCommonMac { 1213 private: 1214 friend ProtocolMethodLists; 1215 1216 ObjCTypesHelper ObjCTypes; 1217 1218 /// EmitModuleInfo - Another marker encoding module level 1219 /// information. 1220 void EmitModuleInfo(); 1221 1222 /// EmitModuleSymols - Emit module symbols, the list of defined 1223 /// classes and categories. The result has type SymtabPtrTy. 1224 llvm::Constant *EmitModuleSymbols(); 1225 1226 /// FinishModule - Write out global data structures at the end of 1227 /// processing a translation unit. 1228 void FinishModule(); 1229 1230 /// EmitClassExtension - Generate the class extension structure used 1231 /// to store the weak ivar layout and properties. The return value 1232 /// has type ClassExtensionPtrTy. 1233 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID, 1234 CharUnits instanceSize, 1235 bool hasMRCWeakIvars, 1236 bool isMetaclass); 1237 1238 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, 1239 /// for the given class. 1240 llvm::Value *EmitClassRef(CodeGenFunction &CGF, 1241 const ObjCInterfaceDecl *ID); 1242 1243 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF, 1244 IdentifierInfo *II); 1245 1246 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; 1247 1248 /// EmitSuperClassRef - Emits reference to class's main metadata class. 1249 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID); 1250 1251 /// EmitIvarList - Emit the ivar list for the given 1252 /// implementation. If ForClass is true the list of class ivars 1253 /// (i.e. metaclass ivars) is emitted, otherwise the list of 1254 /// interface ivars will be emitted. The return value has type 1255 /// IvarListPtrTy. 1256 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID, 1257 bool ForClass); 1258 1259 /// EmitMetaClass - Emit a forward reference to the class structure 1260 /// for the metaclass of the given interface. The return value has 1261 /// type ClassPtrTy. 1262 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID); 1263 1264 /// EmitMetaClass - Emit a class structure for the metaclass of the 1265 /// given implementation. The return value has type ClassPtrTy. 1266 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID, 1267 llvm::Constant *Protocols, 1268 ArrayRef<const ObjCMethodDecl *> Methods); 1269 1270 void emitMethodConstant(ConstantArrayBuilder &builder, 1271 const ObjCMethodDecl *MD); 1272 1273 void emitMethodDescriptionConstant(ConstantArrayBuilder &builder, 1274 const ObjCMethodDecl *MD); 1275 1276 /// EmitMethodList - Emit the method list for the given 1277 /// implementation. The return value has type MethodListPtrTy. 1278 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT, 1279 ArrayRef<const ObjCMethodDecl *> Methods); 1280 1281 /// GetOrEmitProtocol - Get the protocol object for the given 1282 /// declaration, emitting it if necessary. The return value has type 1283 /// ProtocolPtrTy. 1284 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override; 1285 1286 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 1287 /// object for the given declaration, emitting it if needed. These 1288 /// forward references will be filled in with empty bodies if no 1289 /// definition is seen. The return value has type ProtocolPtrTy. 1290 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override; 1291 1292 /// EmitProtocolExtension - Generate the protocol extension 1293 /// structure used to store optional instance and class methods, and 1294 /// protocol properties. The return value has type 1295 /// ProtocolExtensionPtrTy. 1296 llvm::Constant * 1297 EmitProtocolExtension(const ObjCProtocolDecl *PD, 1298 const ProtocolMethodLists &methodLists); 1299 1300 /// EmitProtocolList - Generate the list of referenced 1301 /// protocols. The return value has type ProtocolListPtrTy. 1302 llvm::Constant *EmitProtocolList(Twine Name, 1303 ObjCProtocolDecl::protocol_iterator begin, 1304 ObjCProtocolDecl::protocol_iterator end); 1305 1306 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy, 1307 /// for the given selector. 1308 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel); 1309 Address EmitSelectorAddr(Selector Sel); 1310 1311 public: 1312 CGObjCMac(CodeGen::CodeGenModule &cgm); 1313 1314 llvm::Constant *getNSConstantStringClassRef() override; 1315 1316 llvm::Function *ModuleInitFunction() override; 1317 1318 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 1319 ReturnValueSlot Return, 1320 QualType ResultType, 1321 Selector Sel, llvm::Value *Receiver, 1322 const CallArgList &CallArgs, 1323 const ObjCInterfaceDecl *Class, 1324 const ObjCMethodDecl *Method) override; 1325 1326 CodeGen::RValue 1327 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 1328 ReturnValueSlot Return, QualType ResultType, 1329 Selector Sel, const ObjCInterfaceDecl *Class, 1330 bool isCategoryImpl, llvm::Value *Receiver, 1331 bool IsClassMessage, const CallArgList &CallArgs, 1332 const ObjCMethodDecl *Method) override; 1333 1334 llvm::Value *GetClass(CodeGenFunction &CGF, 1335 const ObjCInterfaceDecl *ID) override; 1336 1337 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override; 1338 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override; 1339 1340 /// The NeXT/Apple runtimes do not support typed selectors; just emit an 1341 /// untyped one. 1342 llvm::Value *GetSelector(CodeGenFunction &CGF, 1343 const ObjCMethodDecl *Method) override; 1344 1345 llvm::Constant *GetEHType(QualType T) override; 1346 1347 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; 1348 1349 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; 1350 1351 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {} 1352 1353 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, 1354 const ObjCProtocolDecl *PD) override; 1355 1356 llvm::FunctionCallee GetPropertyGetFunction() override; 1357 llvm::FunctionCallee GetPropertySetFunction() override; 1358 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, 1359 bool copy) override; 1360 llvm::FunctionCallee GetGetStructFunction() override; 1361 llvm::FunctionCallee GetSetStructFunction() override; 1362 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override; 1363 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override; 1364 llvm::FunctionCallee EnumerationMutationFunction() override; 1365 1366 void EmitTryStmt(CodeGen::CodeGenFunction &CGF, 1367 const ObjCAtTryStmt &S) override; 1368 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 1369 const ObjCAtSynchronizedStmt &S) override; 1370 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S); 1371 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, 1372 bool ClearInsertionPoint=true) override; 1373 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 1374 Address AddrWeakObj) override; 1375 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 1376 llvm::Value *src, Address dst) override; 1377 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 1378 llvm::Value *src, Address dest, 1379 bool threadlocal = false) override; 1380 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 1381 llvm::Value *src, Address dest, 1382 llvm::Value *ivarOffset) override; 1383 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 1384 llvm::Value *src, Address dest) override; 1385 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, 1386 Address dest, Address src, 1387 llvm::Value *size) override; 1388 1389 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, 1390 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, 1391 unsigned CVRQualifiers) override; 1392 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 1393 const ObjCInterfaceDecl *Interface, 1394 const ObjCIvarDecl *Ivar) override; 1395 }; 1396 1397 class CGObjCNonFragileABIMac : public CGObjCCommonMac { 1398 private: 1399 friend ProtocolMethodLists; 1400 ObjCNonFragileABITypesHelper ObjCTypes; 1401 llvm::GlobalVariable* ObjCEmptyCacheVar; 1402 llvm::Constant* ObjCEmptyVtableVar; 1403 1404 /// SuperClassReferences - uniqued super class references. 1405 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences; 1406 1407 /// MetaClassReferences - uniqued meta class references. 1408 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences; 1409 1410 /// EHTypeReferences - uniqued class ehtype references. 1411 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences; 1412 1413 /// VTableDispatchMethods - List of methods for which we generate 1414 /// vtable-based message dispatch. 1415 llvm::DenseSet<Selector> VTableDispatchMethods; 1416 1417 /// DefinedMetaClasses - List of defined meta-classes. 1418 std::vector<llvm::GlobalValue*> DefinedMetaClasses; 1419 1420 /// isVTableDispatchedSelector - Returns true if SEL is a 1421 /// vtable-based selector. 1422 bool isVTableDispatchedSelector(Selector Sel); 1423 1424 /// FinishNonFragileABIModule - Write out global data structures at the end of 1425 /// processing a translation unit. 1426 void FinishNonFragileABIModule(); 1427 1428 /// AddModuleClassList - Add the given list of class pointers to the 1429 /// module with the provided symbol and section names. 1430 void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container, 1431 StringRef SymbolName, StringRef SectionName); 1432 1433 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags, 1434 unsigned InstanceStart, 1435 unsigned InstanceSize, 1436 const ObjCImplementationDecl *ID); 1437 llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI, 1438 bool isMetaclass, 1439 llvm::Constant *IsAGV, 1440 llvm::Constant *SuperClassGV, 1441 llvm::Constant *ClassRoGV, 1442 bool HiddenVisibility); 1443 1444 void emitMethodConstant(ConstantArrayBuilder &builder, 1445 const ObjCMethodDecl *MD, 1446 bool forProtocol); 1447 1448 /// Emit the method list for the given implementation. The return value 1449 /// has type MethodListnfABITy. 1450 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT, 1451 ArrayRef<const ObjCMethodDecl *> Methods); 1452 1453 /// EmitIvarList - Emit the ivar list for the given 1454 /// implementation. If ForClass is true the list of class ivars 1455 /// (i.e. metaclass ivars) is emitted, otherwise the list of 1456 /// interface ivars will be emitted. The return value has type 1457 /// IvarListnfABIPtrTy. 1458 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID); 1459 1460 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID, 1461 const ObjCIvarDecl *Ivar, 1462 unsigned long int offset); 1463 1464 /// GetOrEmitProtocol - Get the protocol object for the given 1465 /// declaration, emitting it if necessary. The return value has type 1466 /// ProtocolPtrTy. 1467 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override; 1468 1469 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 1470 /// object for the given declaration, emitting it if needed. These 1471 /// forward references will be filled in with empty bodies if no 1472 /// definition is seen. The return value has type ProtocolPtrTy. 1473 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override; 1474 1475 /// EmitProtocolList - Generate the list of referenced 1476 /// protocols. The return value has type ProtocolListPtrTy. 1477 llvm::Constant *EmitProtocolList(Twine Name, 1478 ObjCProtocolDecl::protocol_iterator begin, 1479 ObjCProtocolDecl::protocol_iterator end); 1480 1481 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF, 1482 ReturnValueSlot Return, 1483 QualType ResultType, 1484 Selector Sel, 1485 llvm::Value *Receiver, 1486 QualType Arg0Ty, 1487 bool IsSuper, 1488 const CallArgList &CallArgs, 1489 const ObjCMethodDecl *Method); 1490 1491 /// GetClassGlobal - Return the global variable for the Objective-C 1492 /// class of the given name. 1493 llvm::Constant *GetClassGlobal(StringRef Name, 1494 ForDefinition_t IsForDefinition, 1495 bool Weak = false, bool DLLImport = false); 1496 llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID, 1497 bool isMetaclass, 1498 ForDefinition_t isForDefinition); 1499 1500 llvm::Constant *GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID); 1501 1502 llvm::Value *EmitLoadOfClassRef(CodeGenFunction &CGF, 1503 const ObjCInterfaceDecl *ID, 1504 llvm::GlobalVariable *Entry); 1505 1506 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, 1507 /// for the given class reference. 1508 llvm::Value *EmitClassRef(CodeGenFunction &CGF, 1509 const ObjCInterfaceDecl *ID); 1510 1511 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF, 1512 IdentifierInfo *II, 1513 const ObjCInterfaceDecl *ID); 1514 1515 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; 1516 1517 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, 1518 /// for the given super class reference. 1519 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF, 1520 const ObjCInterfaceDecl *ID); 1521 1522 /// EmitMetaClassRef - Return a Value * of the address of _class_t 1523 /// meta-data 1524 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF, 1525 const ObjCInterfaceDecl *ID, bool Weak); 1526 1527 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for 1528 /// the given ivar. 1529 /// 1530 llvm::GlobalVariable * ObjCIvarOffsetVariable( 1531 const ObjCInterfaceDecl *ID, 1532 const ObjCIvarDecl *Ivar); 1533 1534 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy, 1535 /// for the given selector. 1536 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel); 1537 Address EmitSelectorAddr(Selector Sel); 1538 1539 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C 1540 /// interface. The return value has type EHTypePtrTy. 1541 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID, 1542 ForDefinition_t IsForDefinition); 1543 1544 StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; } 1545 1546 StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; } 1547 1548 void GetClassSizeInfo(const ObjCImplementationDecl *OID, 1549 uint32_t &InstanceStart, 1550 uint32_t &InstanceSize); 1551 1552 // Shamelessly stolen from Analysis/CFRefCount.cpp 1553 Selector GetNullarySelector(const char* name) const { 1554 IdentifierInfo* II = &CGM.getContext().Idents.get(name); 1555 return CGM.getContext().Selectors.getSelector(0, &II); 1556 } 1557 1558 Selector GetUnarySelector(const char* name) const { 1559 IdentifierInfo* II = &CGM.getContext().Idents.get(name); 1560 return CGM.getContext().Selectors.getSelector(1, &II); 1561 } 1562 1563 /// ImplementationIsNonLazy - Check whether the given category or 1564 /// class implementation is "non-lazy". 1565 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const; 1566 1567 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF, 1568 const ObjCIvarDecl *IV) { 1569 // Annotate the load as an invariant load iff inside an instance method 1570 // and ivar belongs to instance method's class and one of its super class. 1571 // This check is needed because the ivar offset is a lazily 1572 // initialised value that may depend on objc_msgSend to perform a fixup on 1573 // the first message dispatch. 1574 // 1575 // An additional opportunity to mark the load as invariant arises when the 1576 // base of the ivar access is a parameter to an Objective C method. 1577 // However, because the parameters are not available in the current 1578 // interface, we cannot perform this check. 1579 // 1580 // Note that for direct methods, because objc_msgSend is skipped, 1581 // and that the method may be inlined, this optimization actually 1582 // can't be performed. 1583 if (const ObjCMethodDecl *MD = 1584 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl)) 1585 if (MD->isInstanceMethod() && !MD->isDirectMethod()) 1586 if (const ObjCInterfaceDecl *ID = MD->getClassInterface()) 1587 return IV->getContainingInterface()->isSuperClassOf(ID); 1588 return false; 1589 } 1590 1591 bool isClassLayoutKnownStatically(const ObjCInterfaceDecl *ID) { 1592 // NSObject is a fixed size. If we can see the @implementation of a class 1593 // which inherits from NSObject then we know that all it's offsets also must 1594 // be fixed. FIXME: Can we do this if see a chain of super classes with 1595 // implementations leading to NSObject? 1596 return ID->getImplementation() && ID->getSuperClass() && 1597 ID->getSuperClass()->getName() == "NSObject"; 1598 } 1599 1600 public: 1601 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm); 1602 1603 llvm::Constant *getNSConstantStringClassRef() override; 1604 1605 llvm::Function *ModuleInitFunction() override; 1606 1607 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 1608 ReturnValueSlot Return, 1609 QualType ResultType, Selector Sel, 1610 llvm::Value *Receiver, 1611 const CallArgList &CallArgs, 1612 const ObjCInterfaceDecl *Class, 1613 const ObjCMethodDecl *Method) override; 1614 1615 CodeGen::RValue 1616 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 1617 ReturnValueSlot Return, QualType ResultType, 1618 Selector Sel, const ObjCInterfaceDecl *Class, 1619 bool isCategoryImpl, llvm::Value *Receiver, 1620 bool IsClassMessage, const CallArgList &CallArgs, 1621 const ObjCMethodDecl *Method) override; 1622 1623 llvm::Value *GetClass(CodeGenFunction &CGF, 1624 const ObjCInterfaceDecl *ID) override; 1625 1626 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override 1627 { return EmitSelector(CGF, Sel); } 1628 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override 1629 { return EmitSelectorAddr(Sel); } 1630 1631 /// The NeXT/Apple runtimes do not support typed selectors; just emit an 1632 /// untyped one. 1633 llvm::Value *GetSelector(CodeGenFunction &CGF, 1634 const ObjCMethodDecl *Method) override 1635 { return EmitSelector(CGF, Method->getSelector()); } 1636 1637 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; 1638 1639 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; 1640 1641 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {} 1642 1643 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, 1644 const ObjCProtocolDecl *PD) override; 1645 1646 llvm::Constant *GetEHType(QualType T) override; 1647 1648 llvm::FunctionCallee GetPropertyGetFunction() override { 1649 return ObjCTypes.getGetPropertyFn(); 1650 } 1651 llvm::FunctionCallee GetPropertySetFunction() override { 1652 return ObjCTypes.getSetPropertyFn(); 1653 } 1654 1655 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, 1656 bool copy) override { 1657 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy); 1658 } 1659 1660 llvm::FunctionCallee GetSetStructFunction() override { 1661 return ObjCTypes.getCopyStructFn(); 1662 } 1663 1664 llvm::FunctionCallee GetGetStructFunction() override { 1665 return ObjCTypes.getCopyStructFn(); 1666 } 1667 1668 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override { 1669 return ObjCTypes.getCppAtomicObjectFunction(); 1670 } 1671 1672 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override { 1673 return ObjCTypes.getCppAtomicObjectFunction(); 1674 } 1675 1676 llvm::FunctionCallee EnumerationMutationFunction() override { 1677 return ObjCTypes.getEnumerationMutationFn(); 1678 } 1679 1680 void EmitTryStmt(CodeGen::CodeGenFunction &CGF, 1681 const ObjCAtTryStmt &S) override; 1682 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 1683 const ObjCAtSynchronizedStmt &S) override; 1684 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, 1685 bool ClearInsertionPoint=true) override; 1686 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 1687 Address AddrWeakObj) override; 1688 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 1689 llvm::Value *src, Address edst) override; 1690 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 1691 llvm::Value *src, Address dest, 1692 bool threadlocal = false) override; 1693 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 1694 llvm::Value *src, Address dest, 1695 llvm::Value *ivarOffset) override; 1696 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 1697 llvm::Value *src, Address dest) override; 1698 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, 1699 Address dest, Address src, 1700 llvm::Value *size) override; 1701 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, 1702 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, 1703 unsigned CVRQualifiers) override; 1704 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 1705 const ObjCInterfaceDecl *Interface, 1706 const ObjCIvarDecl *Ivar) override; 1707 }; 1708 1709 /// A helper class for performing the null-initialization of a return 1710 /// value. 1711 struct NullReturnState { 1712 llvm::BasicBlock *NullBB; 1713 NullReturnState() : NullBB(nullptr) {} 1714 1715 /// Perform a null-check of the given receiver. 1716 void init(CodeGenFunction &CGF, llvm::Value *receiver) { 1717 // Make blocks for the null-receiver and call edges. 1718 NullBB = CGF.createBasicBlock("msgSend.null-receiver"); 1719 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call"); 1720 1721 // Check for a null receiver and, if there is one, jump to the 1722 // null-receiver block. There's no point in trying to avoid it: 1723 // we're always going to put *something* there, because otherwise 1724 // we shouldn't have done this null-check in the first place. 1725 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver); 1726 CGF.Builder.CreateCondBr(isNull, NullBB, callBB); 1727 1728 // Otherwise, start performing the call. 1729 CGF.EmitBlock(callBB); 1730 } 1731 1732 /// Complete the null-return operation. It is valid to call this 1733 /// regardless of whether 'init' has been called. 1734 RValue complete(CodeGenFunction &CGF, 1735 ReturnValueSlot returnSlot, 1736 RValue result, 1737 QualType resultType, 1738 const CallArgList &CallArgs, 1739 const ObjCMethodDecl *Method) { 1740 // If we never had to do a null-check, just use the raw result. 1741 if (!NullBB) return result; 1742 1743 // The continuation block. This will be left null if we don't have an 1744 // IP, which can happen if the method we're calling is marked noreturn. 1745 llvm::BasicBlock *contBB = nullptr; 1746 1747 // Finish the call path. 1748 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock(); 1749 if (callBB) { 1750 contBB = CGF.createBasicBlock("msgSend.cont"); 1751 CGF.Builder.CreateBr(contBB); 1752 } 1753 1754 // Okay, start emitting the null-receiver block. 1755 CGF.EmitBlock(NullBB); 1756 1757 // Destroy any consumed arguments we've got. 1758 if (Method) { 1759 CGObjCRuntime::destroyCalleeDestroyedArguments(CGF, Method, CallArgs); 1760 } 1761 1762 // The phi code below assumes that we haven't needed any control flow yet. 1763 assert(CGF.Builder.GetInsertBlock() == NullBB); 1764 1765 // If we've got a void return, just jump to the continuation block. 1766 if (result.isScalar() && resultType->isVoidType()) { 1767 // No jumps required if the message-send was noreturn. 1768 if (contBB) CGF.EmitBlock(contBB); 1769 return result; 1770 } 1771 1772 // If we've got a scalar return, build a phi. 1773 if (result.isScalar()) { 1774 // Derive the null-initialization value. 1775 llvm::Value *null = 1776 CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(resultType), resultType); 1777 1778 // If no join is necessary, just flow out. 1779 if (!contBB) return RValue::get(null); 1780 1781 // Otherwise, build a phi. 1782 CGF.EmitBlock(contBB); 1783 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2); 1784 phi->addIncoming(result.getScalarVal(), callBB); 1785 phi->addIncoming(null, NullBB); 1786 return RValue::get(phi); 1787 } 1788 1789 // If we've got an aggregate return, null the buffer out. 1790 // FIXME: maybe we should be doing things differently for all the 1791 // cases where the ABI has us returning (1) non-agg values in 1792 // memory or (2) agg values in registers. 1793 if (result.isAggregate()) { 1794 assert(result.isAggregate() && "null init of non-aggregate result?"); 1795 if (!returnSlot.isUnused()) 1796 CGF.EmitNullInitialization(result.getAggregateAddress(), resultType); 1797 if (contBB) CGF.EmitBlock(contBB); 1798 return result; 1799 } 1800 1801 // Complex types. 1802 CGF.EmitBlock(contBB); 1803 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal(); 1804 1805 // Find the scalar type and its zero value. 1806 llvm::Type *scalarTy = callResult.first->getType(); 1807 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy); 1808 1809 // Build phis for both coordinates. 1810 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2); 1811 real->addIncoming(callResult.first, callBB); 1812 real->addIncoming(scalarZero, NullBB); 1813 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2); 1814 imag->addIncoming(callResult.second, callBB); 1815 imag->addIncoming(scalarZero, NullBB); 1816 return RValue::getComplex(real, imag); 1817 } 1818 }; 1819 1820 } // end anonymous namespace 1821 1822 /* *** Helper Functions *** */ 1823 1824 /// getConstantGEP() - Help routine to construct simple GEPs. 1825 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext, 1826 llvm::GlobalVariable *C, unsigned idx0, 1827 unsigned idx1) { 1828 llvm::Value *Idxs[] = { 1829 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0), 1830 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1) 1831 }; 1832 return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs); 1833 } 1834 1835 /// hasObjCExceptionAttribute - Return true if this class or any super 1836 /// class has the __objc_exception__ attribute. 1837 static bool hasObjCExceptionAttribute(ASTContext &Context, 1838 const ObjCInterfaceDecl *OID) { 1839 if (OID->hasAttr<ObjCExceptionAttr>()) 1840 return true; 1841 if (const ObjCInterfaceDecl *Super = OID->getSuperClass()) 1842 return hasObjCExceptionAttribute(Context, Super); 1843 return false; 1844 } 1845 1846 static llvm::GlobalValue::LinkageTypes 1847 getLinkageTypeForObjCMetadata(CodeGenModule &CGM, StringRef Section) { 1848 if (CGM.getTriple().isOSBinFormatMachO() && 1849 (Section.empty() || Section.startswith("__DATA"))) 1850 return llvm::GlobalValue::InternalLinkage; 1851 return llvm::GlobalValue::PrivateLinkage; 1852 } 1853 1854 /// A helper function to create an internal or private global variable. 1855 static llvm::GlobalVariable * 1856 finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder, 1857 const llvm::Twine &Name, CodeGenModule &CGM) { 1858 std::string SectionName; 1859 if (CGM.getTriple().isOSBinFormatMachO()) 1860 SectionName = "__DATA, __objc_const"; 1861 auto *GV = Builder.finishAndCreateGlobal( 1862 Name, CGM.getPointerAlign(), /*constant*/ false, 1863 getLinkageTypeForObjCMetadata(CGM, SectionName)); 1864 GV->setSection(SectionName); 1865 return GV; 1866 } 1867 1868 /* *** CGObjCMac Public Interface *** */ 1869 1870 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm), 1871 ObjCTypes(cgm) { 1872 ObjCABI = 1; 1873 EmitImageInfo(); 1874 } 1875 1876 /// GetClass - Return a reference to the class for the given interface 1877 /// decl. 1878 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF, 1879 const ObjCInterfaceDecl *ID) { 1880 return EmitClassRef(CGF, ID); 1881 } 1882 1883 /// GetSelector - Return the pointer to the unique'd string for this selector. 1884 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) { 1885 return EmitSelector(CGF, Sel); 1886 } 1887 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) { 1888 return EmitSelectorAddr(Sel); 1889 } 1890 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl 1891 *Method) { 1892 return EmitSelector(CGF, Method->getSelector()); 1893 } 1894 1895 llvm::Constant *CGObjCMac::GetEHType(QualType T) { 1896 if (T->isObjCIdType() || 1897 T->isObjCQualifiedIdType()) { 1898 return CGM.GetAddrOfRTTIDescriptor( 1899 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true); 1900 } 1901 if (T->isObjCClassType() || 1902 T->isObjCQualifiedClassType()) { 1903 return CGM.GetAddrOfRTTIDescriptor( 1904 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true); 1905 } 1906 if (T->isObjCObjectPointerType()) 1907 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true); 1908 1909 llvm_unreachable("asking for catch type for ObjC type in fragile runtime"); 1910 } 1911 1912 /// Generate a constant CFString object. 1913 /* 1914 struct __builtin_CFString { 1915 const int *isa; // point to __CFConstantStringClassReference 1916 int flags; 1917 const char *str; 1918 long length; 1919 }; 1920 */ 1921 1922 /// or Generate a constant NSString object. 1923 /* 1924 struct __builtin_NSString { 1925 const int *isa; // point to __NSConstantStringClassReference 1926 const char *str; 1927 unsigned int length; 1928 }; 1929 */ 1930 1931 ConstantAddress 1932 CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) { 1933 return (!CGM.getLangOpts().NoConstantCFStrings 1934 ? CGM.GetAddrOfConstantCFString(SL) 1935 : GenerateConstantNSString(SL)); 1936 } 1937 1938 static llvm::StringMapEntry<llvm::GlobalVariable *> & 1939 GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map, 1940 const StringLiteral *Literal, unsigned &StringLength) { 1941 StringRef String = Literal->getString(); 1942 StringLength = String.size(); 1943 return *Map.insert(std::make_pair(String, nullptr)).first; 1944 } 1945 1946 llvm::Constant *CGObjCMac::getNSConstantStringClassRef() { 1947 if (llvm::Value *V = ConstantStringClassRef) 1948 return cast<llvm::Constant>(V); 1949 1950 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass; 1951 std::string str = 1952 StringClass.empty() ? "_NSConstantStringClassReference" 1953 : "_" + StringClass + "ClassReference"; 1954 1955 llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0); 1956 auto GV = CGM.CreateRuntimeVariable(PTy, str); 1957 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo()); 1958 ConstantStringClassRef = V; 1959 return V; 1960 } 1961 1962 llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() { 1963 if (llvm::Value *V = ConstantStringClassRef) 1964 return cast<llvm::Constant>(V); 1965 1966 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass; 1967 std::string str = 1968 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" 1969 : "OBJC_CLASS_$_" + StringClass; 1970 llvm::Constant *GV = GetClassGlobal(str, NotForDefinition); 1971 1972 // Make sure the result is of the correct type. 1973 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo()); 1974 1975 ConstantStringClassRef = V; 1976 return V; 1977 } 1978 1979 ConstantAddress 1980 CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) { 1981 unsigned StringLength = 0; 1982 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = 1983 GetConstantStringEntry(NSConstantStringMap, Literal, StringLength); 1984 1985 if (auto *C = Entry.second) 1986 return ConstantAddress( 1987 C, C->getValueType(), CharUnits::fromQuantity(C->getAlignment())); 1988 1989 // If we don't already have it, get _NSConstantStringClassReference. 1990 llvm::Constant *Class = getNSConstantStringClassRef(); 1991 1992 // If we don't already have it, construct the type for a constant NSString. 1993 if (!NSConstantStringType) { 1994 NSConstantStringType = 1995 llvm::StructType::create({ 1996 CGM.Int32Ty->getPointerTo(), 1997 CGM.Int8PtrTy, 1998 CGM.IntTy 1999 }, "struct.__builtin_NSString"); 2000 } 2001 2002 ConstantInitBuilder Builder(CGM); 2003 auto Fields = Builder.beginStruct(NSConstantStringType); 2004 2005 // Class pointer. 2006 Fields.add(Class); 2007 2008 // String pointer. 2009 llvm::Constant *C = 2010 llvm::ConstantDataArray::getString(VMContext, Entry.first()); 2011 2012 llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage; 2013 bool isConstant = !CGM.getLangOpts().WritableStrings; 2014 2015 auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant, 2016 Linkage, C, ".str"); 2017 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 2018 // Don't enforce the target's minimum global alignment, since the only use 2019 // of the string is via this class initializer. 2020 GV->setAlignment(llvm::Align(1)); 2021 Fields.addBitCast(GV, CGM.Int8PtrTy); 2022 2023 // String length. 2024 Fields.addInt(CGM.IntTy, StringLength); 2025 2026 // The struct. 2027 CharUnits Alignment = CGM.getPointerAlign(); 2028 GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment, 2029 /*constant*/ true, 2030 llvm::GlobalVariable::PrivateLinkage); 2031 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip"; 2032 const char *NSStringNonFragileABISection = 2033 "__DATA,__objc_stringobj,regular,no_dead_strip"; 2034 // FIXME. Fix section. 2035 GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile() 2036 ? NSStringNonFragileABISection 2037 : NSStringSection); 2038 Entry.second = GV; 2039 2040 return ConstantAddress(GV, GV->getValueType(), Alignment); 2041 } 2042 2043 enum { 2044 kCFTaggedObjectID_Integer = (1 << 1) + 1 2045 }; 2046 2047 /// Generates a message send where the super is the receiver. This is 2048 /// a message send to self with special delivery semantics indicating 2049 /// which class's method should be called. 2050 CodeGen::RValue 2051 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 2052 ReturnValueSlot Return, 2053 QualType ResultType, 2054 Selector Sel, 2055 const ObjCInterfaceDecl *Class, 2056 bool isCategoryImpl, 2057 llvm::Value *Receiver, 2058 bool IsClassMessage, 2059 const CodeGen::CallArgList &CallArgs, 2060 const ObjCMethodDecl *Method) { 2061 // Create and init a super structure; this is a (receiver, class) 2062 // pair we will pass to objc_msgSendSuper. 2063 Address ObjCSuper = 2064 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(), 2065 "objc_super"); 2066 llvm::Value *ReceiverAsObject = 2067 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy); 2068 CGF.Builder.CreateStore(ReceiverAsObject, 2069 CGF.Builder.CreateStructGEP(ObjCSuper, 0)); 2070 2071 // If this is a class message the metaclass is passed as the target. 2072 llvm::Type *ClassTyPtr = llvm::PointerType::getUnqual(ObjCTypes.ClassTy); 2073 llvm::Value *Target; 2074 if (IsClassMessage) { 2075 if (isCategoryImpl) { 2076 // Message sent to 'super' in a class method defined in a category 2077 // implementation requires an odd treatment. 2078 // If we are in a class method, we must retrieve the 2079 // _metaclass_ for the current class, pointed at by 2080 // the class's "isa" pointer. The following assumes that 2081 // isa" is the first ivar in a class (which it must be). 2082 Target = EmitClassRef(CGF, Class->getSuperClass()); 2083 Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0); 2084 Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, Target, 2085 CGF.getPointerAlign()); 2086 } else { 2087 llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class); 2088 llvm::Value *SuperPtr = 2089 CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1); 2090 llvm::Value *Super = CGF.Builder.CreateAlignedLoad(ClassTyPtr, SuperPtr, 2091 CGF.getPointerAlign()); 2092 Target = Super; 2093 } 2094 } else if (isCategoryImpl) 2095 Target = EmitClassRef(CGF, Class->getSuperClass()); 2096 else { 2097 llvm::Value *ClassPtr = EmitSuperClassRef(Class); 2098 ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1); 2099 Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, ClassPtr, 2100 CGF.getPointerAlign()); 2101 } 2102 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and 2103 // ObjCTypes types. 2104 llvm::Type *ClassTy = 2105 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType()); 2106 Target = CGF.Builder.CreateBitCast(Target, ClassTy); 2107 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1)); 2108 return EmitMessageSend(CGF, Return, ResultType, Sel, ObjCSuper.getPointer(), 2109 ObjCTypes.SuperPtrCTy, true, CallArgs, Method, Class, 2110 ObjCTypes); 2111 } 2112 2113 /// Generate code for a message send expression. 2114 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 2115 ReturnValueSlot Return, 2116 QualType ResultType, 2117 Selector Sel, 2118 llvm::Value *Receiver, 2119 const CallArgList &CallArgs, 2120 const ObjCInterfaceDecl *Class, 2121 const ObjCMethodDecl *Method) { 2122 return EmitMessageSend(CGF, Return, ResultType, Sel, Receiver, 2123 CGF.getContext().getObjCIdType(), false, CallArgs, 2124 Method, Class, ObjCTypes); 2125 } 2126 2127 CodeGen::RValue 2128 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF, 2129 ReturnValueSlot Return, 2130 QualType ResultType, 2131 Selector Sel, 2132 llvm::Value *Arg0, 2133 QualType Arg0Ty, 2134 bool IsSuper, 2135 const CallArgList &CallArgs, 2136 const ObjCMethodDecl *Method, 2137 const ObjCInterfaceDecl *ClassReceiver, 2138 const ObjCCommonTypesHelper &ObjCTypes) { 2139 CodeGenTypes &Types = CGM.getTypes(); 2140 auto selTy = CGF.getContext().getObjCSelType(); 2141 llvm::Value *SelValue = llvm::UndefValue::get(Types.ConvertType(selTy)); 2142 2143 CallArgList ActualArgs; 2144 if (!IsSuper) 2145 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy); 2146 ActualArgs.add(RValue::get(Arg0), Arg0Ty); 2147 ActualArgs.add(RValue::get(SelValue), selTy); 2148 ActualArgs.addFrom(CallArgs); 2149 2150 // If we're calling a method, use the formal signature. 2151 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs); 2152 2153 if (Method) 2154 assert(CGM.getContext().getCanonicalType(Method->getReturnType()) == 2155 CGM.getContext().getCanonicalType(ResultType) && 2156 "Result type mismatch!"); 2157 2158 bool ReceiverCanBeNull = 2159 canMessageReceiverBeNull(CGF, Method, IsSuper, ClassReceiver, Arg0); 2160 2161 bool RequiresNullCheck = false; 2162 bool RequiresSelValue = true; 2163 2164 llvm::FunctionCallee Fn = nullptr; 2165 if (Method && Method->isDirectMethod()) { 2166 assert(!IsSuper); 2167 Fn = GenerateDirectMethod(Method, Method->getClassInterface()); 2168 // Direct methods will synthesize the proper `_cmd` internally, 2169 // so just don't bother with setting the `_cmd` argument. 2170 RequiresSelValue = false; 2171 } else if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) { 2172 if (ReceiverCanBeNull) RequiresNullCheck = true; 2173 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper) 2174 : ObjCTypes.getSendStretFn(IsSuper); 2175 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) { 2176 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper) 2177 : ObjCTypes.getSendFpretFn(IsSuper); 2178 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) { 2179 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper) 2180 : ObjCTypes.getSendFp2retFn(IsSuper); 2181 } else { 2182 // arm64 uses objc_msgSend for stret methods and yet null receiver check 2183 // must be made for it. 2184 if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo)) 2185 RequiresNullCheck = true; 2186 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper) 2187 : ObjCTypes.getSendFn(IsSuper); 2188 } 2189 2190 // Cast function to proper signature 2191 llvm::Constant *BitcastFn = cast<llvm::Constant>( 2192 CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType)); 2193 2194 // We don't need to emit a null check to zero out an indirect result if the 2195 // result is ignored. 2196 if (Return.isUnused()) 2197 RequiresNullCheck = false; 2198 2199 // Emit a null-check if there's a consumed argument other than the receiver. 2200 if (!RequiresNullCheck && Method && Method->hasParamDestroyedInCallee()) 2201 RequiresNullCheck = true; 2202 2203 NullReturnState nullReturn; 2204 if (RequiresNullCheck) { 2205 nullReturn.init(CGF, Arg0); 2206 } 2207 2208 // If a selector value needs to be passed, emit the load before the call. 2209 if (RequiresSelValue) { 2210 SelValue = GetSelector(CGF, Sel); 2211 ActualArgs[1] = CallArg(RValue::get(SelValue), selTy); 2212 } 2213 2214 llvm::CallBase *CallSite; 2215 CGCallee Callee = CGCallee::forDirect(BitcastFn); 2216 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs, 2217 &CallSite); 2218 2219 // Mark the call as noreturn if the method is marked noreturn and the 2220 // receiver cannot be null. 2221 if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) { 2222 CallSite->setDoesNotReturn(); 2223 } 2224 2225 return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs, 2226 RequiresNullCheck ? Method : nullptr); 2227 } 2228 2229 static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT, 2230 bool pointee = false) { 2231 // Note that GC qualification applies recursively to C pointer types 2232 // that aren't otherwise decorated. This is weird, but it's probably 2233 // an intentional workaround to the unreliable placement of GC qualifiers. 2234 if (FQT.isObjCGCStrong()) 2235 return Qualifiers::Strong; 2236 2237 if (FQT.isObjCGCWeak()) 2238 return Qualifiers::Weak; 2239 2240 if (auto ownership = FQT.getObjCLifetime()) { 2241 // Ownership does not apply recursively to C pointer types. 2242 if (pointee) return Qualifiers::GCNone; 2243 switch (ownership) { 2244 case Qualifiers::OCL_Weak: return Qualifiers::Weak; 2245 case Qualifiers::OCL_Strong: return Qualifiers::Strong; 2246 case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone; 2247 case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?"); 2248 case Qualifiers::OCL_None: llvm_unreachable("known nonzero"); 2249 } 2250 llvm_unreachable("bad objc ownership"); 2251 } 2252 2253 // Treat unqualified retainable pointers as strong. 2254 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType()) 2255 return Qualifiers::Strong; 2256 2257 // Walk into C pointer types, but only in GC. 2258 if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) { 2259 if (const PointerType *PT = FQT->getAs<PointerType>()) 2260 return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true); 2261 } 2262 2263 return Qualifiers::GCNone; 2264 } 2265 2266 namespace { 2267 struct IvarInfo { 2268 CharUnits Offset; 2269 uint64_t SizeInWords; 2270 IvarInfo(CharUnits offset, uint64_t sizeInWords) 2271 : Offset(offset), SizeInWords(sizeInWords) {} 2272 2273 // Allow sorting based on byte pos. 2274 bool operator<(const IvarInfo &other) const { 2275 return Offset < other.Offset; 2276 } 2277 }; 2278 2279 /// A helper class for building GC layout strings. 2280 class IvarLayoutBuilder { 2281 CodeGenModule &CGM; 2282 2283 /// The start of the layout. Offsets will be relative to this value, 2284 /// and entries less than this value will be silently discarded. 2285 CharUnits InstanceBegin; 2286 2287 /// The end of the layout. Offsets will never exceed this value. 2288 CharUnits InstanceEnd; 2289 2290 /// Whether we're generating the strong layout or the weak layout. 2291 bool ForStrongLayout; 2292 2293 /// Whether the offsets in IvarsInfo might be out-of-order. 2294 bool IsDisordered = false; 2295 2296 llvm::SmallVector<IvarInfo, 8> IvarsInfo; 2297 2298 public: 2299 IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin, 2300 CharUnits instanceEnd, bool forStrongLayout) 2301 : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd), 2302 ForStrongLayout(forStrongLayout) { 2303 } 2304 2305 void visitRecord(const RecordType *RT, CharUnits offset); 2306 2307 template <class Iterator, class GetOffsetFn> 2308 void visitAggregate(Iterator begin, Iterator end, 2309 CharUnits aggrOffset, 2310 const GetOffsetFn &getOffset); 2311 2312 void visitField(const FieldDecl *field, CharUnits offset); 2313 2314 /// Add the layout of a block implementation. 2315 void visitBlock(const CGBlockInfo &blockInfo); 2316 2317 /// Is there any information for an interesting bitmap? 2318 bool hasBitmapData() const { return !IvarsInfo.empty(); } 2319 2320 llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC, 2321 llvm::SmallVectorImpl<unsigned char> &buffer); 2322 2323 static void dump(ArrayRef<unsigned char> buffer) { 2324 const unsigned char *s = buffer.data(); 2325 for (unsigned i = 0, e = buffer.size(); i < e; i++) 2326 if (!(s[i] & 0xf0)) 2327 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : ""); 2328 else 2329 printf("0x%x%s", s[i], s[i] != 0 ? ", " : ""); 2330 printf("\n"); 2331 } 2332 }; 2333 } // end anonymous namespace 2334 2335 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM, 2336 const CGBlockInfo &blockInfo) { 2337 2338 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); 2339 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) 2340 return nullPtr; 2341 2342 IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize, 2343 /*for strong layout*/ true); 2344 2345 builder.visitBlock(blockInfo); 2346 2347 if (!builder.hasBitmapData()) 2348 return nullPtr; 2349 2350 llvm::SmallVector<unsigned char, 32> buffer; 2351 llvm::Constant *C = builder.buildBitmap(*this, buffer); 2352 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) { 2353 printf("\n block variable layout for block: "); 2354 builder.dump(buffer); 2355 } 2356 2357 return C; 2358 } 2359 2360 void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) { 2361 // __isa is the first field in block descriptor and must assume by runtime's 2362 // convention that it is GC'able. 2363 IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1)); 2364 2365 const BlockDecl *blockDecl = blockInfo.getBlockDecl(); 2366 2367 // Ignore the optional 'this' capture: C++ objects are not assumed 2368 // to be GC'ed. 2369 2370 CharUnits lastFieldOffset; 2371 2372 // Walk the captured variables. 2373 for (const auto &CI : blockDecl->captures()) { 2374 const VarDecl *variable = CI.getVariable(); 2375 QualType type = variable->getType(); 2376 2377 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); 2378 2379 // Ignore constant captures. 2380 if (capture.isConstant()) continue; 2381 2382 CharUnits fieldOffset = capture.getOffset(); 2383 2384 // Block fields are not necessarily ordered; if we detect that we're 2385 // adding them out-of-order, make sure we sort later. 2386 if (fieldOffset < lastFieldOffset) 2387 IsDisordered = true; 2388 lastFieldOffset = fieldOffset; 2389 2390 // __block variables are passed by their descriptor address. 2391 if (CI.isByRef()) { 2392 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1)); 2393 continue; 2394 } 2395 2396 assert(!type->isArrayType() && "array variable should not be caught"); 2397 if (const RecordType *record = type->getAs<RecordType>()) { 2398 visitRecord(record, fieldOffset); 2399 continue; 2400 } 2401 2402 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type); 2403 2404 if (GCAttr == Qualifiers::Strong) { 2405 assert(CGM.getContext().getTypeSize(type) 2406 == CGM.getTarget().getPointerWidth(0)); 2407 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1)); 2408 } 2409 } 2410 } 2411 2412 /// getBlockCaptureLifetime - This routine returns life time of the captured 2413 /// block variable for the purpose of block layout meta-data generation. FQT is 2414 /// the type of the variable captured in the block. 2415 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT, 2416 bool ByrefLayout) { 2417 // If it has an ownership qualifier, we're done. 2418 if (auto lifetime = FQT.getObjCLifetime()) 2419 return lifetime; 2420 2421 // If it doesn't, and this is ARC, it has no ownership. 2422 if (CGM.getLangOpts().ObjCAutoRefCount) 2423 return Qualifiers::OCL_None; 2424 2425 // In MRC, retainable pointers are owned by non-__block variables. 2426 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType()) 2427 return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong; 2428 2429 return Qualifiers::OCL_None; 2430 } 2431 2432 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref, 2433 Qualifiers::ObjCLifetime LifeTime, 2434 CharUnits FieldOffset, 2435 CharUnits FieldSize) { 2436 // __block variables are passed by their descriptor address. 2437 if (IsByref) 2438 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset, 2439 FieldSize)); 2440 else if (LifeTime == Qualifiers::OCL_Strong) 2441 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset, 2442 FieldSize)); 2443 else if (LifeTime == Qualifiers::OCL_Weak) 2444 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset, 2445 FieldSize)); 2446 else if (LifeTime == Qualifiers::OCL_ExplicitNone) 2447 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset, 2448 FieldSize)); 2449 else 2450 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES, 2451 FieldOffset, 2452 FieldSize)); 2453 } 2454 2455 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout, 2456 const RecordDecl *RD, 2457 ArrayRef<const FieldDecl*> RecFields, 2458 CharUnits BytePos, bool &HasUnion, 2459 bool ByrefLayout) { 2460 bool IsUnion = (RD && RD->isUnion()); 2461 CharUnits MaxUnionSize = CharUnits::Zero(); 2462 const FieldDecl *MaxField = nullptr; 2463 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr; 2464 CharUnits MaxFieldOffset = CharUnits::Zero(); 2465 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero(); 2466 2467 if (RecFields.empty()) 2468 return; 2469 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); 2470 2471 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 2472 const FieldDecl *Field = RecFields[i]; 2473 // Note that 'i' here is actually the field index inside RD of Field, 2474 // although this dependency is hidden. 2475 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); 2476 CharUnits FieldOffset = 2477 CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i)); 2478 2479 // Skip over unnamed or bitfields 2480 if (!Field->getIdentifier() || Field->isBitField()) { 2481 LastFieldBitfieldOrUnnamed = Field; 2482 LastBitfieldOrUnnamedOffset = FieldOffset; 2483 continue; 2484 } 2485 2486 LastFieldBitfieldOrUnnamed = nullptr; 2487 QualType FQT = Field->getType(); 2488 if (FQT->isRecordType() || FQT->isUnionType()) { 2489 if (FQT->isUnionType()) 2490 HasUnion = true; 2491 2492 BuildRCBlockVarRecordLayout(FQT->castAs<RecordType>(), 2493 BytePos + FieldOffset, HasUnion); 2494 continue; 2495 } 2496 2497 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { 2498 auto *CArray = cast<ConstantArrayType>(Array); 2499 uint64_t ElCount = CArray->getSize().getZExtValue(); 2500 assert(CArray && "only array with known element size is supported"); 2501 FQT = CArray->getElementType(); 2502 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { 2503 auto *CArray = cast<ConstantArrayType>(Array); 2504 ElCount *= CArray->getSize().getZExtValue(); 2505 FQT = CArray->getElementType(); 2506 } 2507 if (FQT->isRecordType() && ElCount) { 2508 int OldIndex = RunSkipBlockVars.size() - 1; 2509 auto *RT = FQT->castAs<RecordType>(); 2510 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset, HasUnion); 2511 2512 // Replicate layout information for each array element. Note that 2513 // one element is already done. 2514 uint64_t ElIx = 1; 2515 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) { 2516 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT); 2517 for (int i = OldIndex+1; i <= FirstIndex; ++i) 2518 RunSkipBlockVars.push_back( 2519 RUN_SKIP(RunSkipBlockVars[i].opcode, 2520 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx, 2521 RunSkipBlockVars[i].block_var_size)); 2522 } 2523 continue; 2524 } 2525 } 2526 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType()); 2527 if (IsUnion) { 2528 CharUnits UnionIvarSize = FieldSize; 2529 if (UnionIvarSize > MaxUnionSize) { 2530 MaxUnionSize = UnionIvarSize; 2531 MaxField = Field; 2532 MaxFieldOffset = FieldOffset; 2533 } 2534 } else { 2535 UpdateRunSkipBlockVars(false, 2536 getBlockCaptureLifetime(FQT, ByrefLayout), 2537 BytePos + FieldOffset, 2538 FieldSize); 2539 } 2540 } 2541 2542 if (LastFieldBitfieldOrUnnamed) { 2543 if (LastFieldBitfieldOrUnnamed->isBitField()) { 2544 // Last field was a bitfield. Must update the info. 2545 uint64_t BitFieldSize 2546 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext()); 2547 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) + 2548 ((BitFieldSize % ByteSizeInBits) != 0); 2549 CharUnits Size = CharUnits::fromQuantity(UnsSize); 2550 Size += LastBitfieldOrUnnamedOffset; 2551 UpdateRunSkipBlockVars(false, 2552 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(), 2553 ByrefLayout), 2554 BytePos + LastBitfieldOrUnnamedOffset, 2555 Size); 2556 } else { 2557 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed"); 2558 // Last field was unnamed. Must update skip info. 2559 CharUnits FieldSize 2560 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType()); 2561 UpdateRunSkipBlockVars(false, 2562 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(), 2563 ByrefLayout), 2564 BytePos + LastBitfieldOrUnnamedOffset, 2565 FieldSize); 2566 } 2567 } 2568 2569 if (MaxField) 2570 UpdateRunSkipBlockVars(false, 2571 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout), 2572 BytePos + MaxFieldOffset, 2573 MaxUnionSize); 2574 } 2575 2576 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT, 2577 CharUnits BytePos, 2578 bool &HasUnion, 2579 bool ByrefLayout) { 2580 const RecordDecl *RD = RT->getDecl(); 2581 SmallVector<const FieldDecl*, 16> Fields(RD->fields()); 2582 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0)); 2583 const llvm::StructLayout *RecLayout = 2584 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty)); 2585 2586 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout); 2587 } 2588 2589 /// InlineLayoutInstruction - This routine produce an inline instruction for the 2590 /// block variable layout if it can. If not, it returns 0. Rules are as follow: 2591 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world, 2592 /// an inline layout of value 0x0000000000000xyz is interpreted as follows: 2593 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by 2594 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by 2595 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero 2596 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no 2597 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured. 2598 uint64_t CGObjCCommonMac::InlineLayoutInstruction( 2599 SmallVectorImpl<unsigned char> &Layout) { 2600 uint64_t Result = 0; 2601 if (Layout.size() <= 3) { 2602 unsigned size = Layout.size(); 2603 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0; 2604 unsigned char inst; 2605 enum BLOCK_LAYOUT_OPCODE opcode ; 2606 switch (size) { 2607 case 3: 2608 inst = Layout[0]; 2609 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2610 if (opcode == BLOCK_LAYOUT_STRONG) 2611 strong_word_count = (inst & 0xF)+1; 2612 else 2613 return 0; 2614 inst = Layout[1]; 2615 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2616 if (opcode == BLOCK_LAYOUT_BYREF) 2617 byref_word_count = (inst & 0xF)+1; 2618 else 2619 return 0; 2620 inst = Layout[2]; 2621 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2622 if (opcode == BLOCK_LAYOUT_WEAK) 2623 weak_word_count = (inst & 0xF)+1; 2624 else 2625 return 0; 2626 break; 2627 2628 case 2: 2629 inst = Layout[0]; 2630 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2631 if (opcode == BLOCK_LAYOUT_STRONG) { 2632 strong_word_count = (inst & 0xF)+1; 2633 inst = Layout[1]; 2634 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2635 if (opcode == BLOCK_LAYOUT_BYREF) 2636 byref_word_count = (inst & 0xF)+1; 2637 else if (opcode == BLOCK_LAYOUT_WEAK) 2638 weak_word_count = (inst & 0xF)+1; 2639 else 2640 return 0; 2641 } 2642 else if (opcode == BLOCK_LAYOUT_BYREF) { 2643 byref_word_count = (inst & 0xF)+1; 2644 inst = Layout[1]; 2645 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2646 if (opcode == BLOCK_LAYOUT_WEAK) 2647 weak_word_count = (inst & 0xF)+1; 2648 else 2649 return 0; 2650 } 2651 else 2652 return 0; 2653 break; 2654 2655 case 1: 2656 inst = Layout[0]; 2657 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2658 if (opcode == BLOCK_LAYOUT_STRONG) 2659 strong_word_count = (inst & 0xF)+1; 2660 else if (opcode == BLOCK_LAYOUT_BYREF) 2661 byref_word_count = (inst & 0xF)+1; 2662 else if (opcode == BLOCK_LAYOUT_WEAK) 2663 weak_word_count = (inst & 0xF)+1; 2664 else 2665 return 0; 2666 break; 2667 2668 default: 2669 return 0; 2670 } 2671 2672 // Cannot inline when any of the word counts is 15. Because this is one less 2673 // than the actual work count (so 15 means 16 actual word counts), 2674 // and we can only display 0 thru 15 word counts. 2675 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16) 2676 return 0; 2677 2678 unsigned count = 2679 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0); 2680 2681 if (size == count) { 2682 if (strong_word_count) 2683 Result = strong_word_count; 2684 Result <<= 4; 2685 if (byref_word_count) 2686 Result += byref_word_count; 2687 Result <<= 4; 2688 if (weak_word_count) 2689 Result += weak_word_count; 2690 } 2691 } 2692 return Result; 2693 } 2694 2695 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) { 2696 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); 2697 if (RunSkipBlockVars.empty()) 2698 return nullPtr; 2699 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0); 2700 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); 2701 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits; 2702 2703 // Sort on byte position; captures might not be allocated in order, 2704 // and unions can do funny things. 2705 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end()); 2706 SmallVector<unsigned char, 16> Layout; 2707 2708 unsigned size = RunSkipBlockVars.size(); 2709 for (unsigned i = 0; i < size; i++) { 2710 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode; 2711 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos; 2712 CharUnits end_byte_pos = start_byte_pos; 2713 unsigned j = i+1; 2714 while (j < size) { 2715 if (opcode == RunSkipBlockVars[j].opcode) { 2716 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos; 2717 i++; 2718 } 2719 else 2720 break; 2721 } 2722 CharUnits size_in_bytes = 2723 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size; 2724 if (j < size) { 2725 CharUnits gap = 2726 RunSkipBlockVars[j].block_var_bytepos - 2727 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size; 2728 size_in_bytes += gap; 2729 } 2730 CharUnits residue_in_bytes = CharUnits::Zero(); 2731 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) { 2732 residue_in_bytes = size_in_bytes % WordSizeInBytes; 2733 size_in_bytes -= residue_in_bytes; 2734 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS; 2735 } 2736 2737 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes; 2738 while (size_in_words >= 16) { 2739 // Note that value in imm. is one less that the actual 2740 // value. So, 0xf means 16 words follow! 2741 unsigned char inst = (opcode << 4) | 0xf; 2742 Layout.push_back(inst); 2743 size_in_words -= 16; 2744 } 2745 if (size_in_words > 0) { 2746 // Note that value in imm. is one less that the actual 2747 // value. So, we subtract 1 away! 2748 unsigned char inst = (opcode << 4) | (size_in_words-1); 2749 Layout.push_back(inst); 2750 } 2751 if (residue_in_bytes > CharUnits::Zero()) { 2752 unsigned char inst = 2753 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1); 2754 Layout.push_back(inst); 2755 } 2756 } 2757 2758 while (!Layout.empty()) { 2759 unsigned char inst = Layout.back(); 2760 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2761 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS) 2762 Layout.pop_back(); 2763 else 2764 break; 2765 } 2766 2767 uint64_t Result = InlineLayoutInstruction(Layout); 2768 if (Result != 0) { 2769 // Block variable layout instruction has been inlined. 2770 if (CGM.getLangOpts().ObjCGCBitmapPrint) { 2771 if (ComputeByrefLayout) 2772 printf("\n Inline BYREF variable layout: "); 2773 else 2774 printf("\n Inline block variable layout: "); 2775 printf("0x0%" PRIx64 "", Result); 2776 if (auto numStrong = (Result & 0xF00) >> 8) 2777 printf(", BL_STRONG:%d", (int) numStrong); 2778 if (auto numByref = (Result & 0x0F0) >> 4) 2779 printf(", BL_BYREF:%d", (int) numByref); 2780 if (auto numWeak = (Result & 0x00F) >> 0) 2781 printf(", BL_WEAK:%d", (int) numWeak); 2782 printf(", BL_OPERATOR:0\n"); 2783 } 2784 return llvm::ConstantInt::get(CGM.IntPtrTy, Result); 2785 } 2786 2787 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0; 2788 Layout.push_back(inst); 2789 std::string BitMap; 2790 for (unsigned i = 0, e = Layout.size(); i != e; i++) 2791 BitMap += Layout[i]; 2792 2793 if (CGM.getLangOpts().ObjCGCBitmapPrint) { 2794 if (ComputeByrefLayout) 2795 printf("\n Byref variable layout: "); 2796 else 2797 printf("\n Block variable layout: "); 2798 for (unsigned i = 0, e = BitMap.size(); i != e; i++) { 2799 unsigned char inst = BitMap[i]; 2800 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); 2801 unsigned delta = 1; 2802 switch (opcode) { 2803 case BLOCK_LAYOUT_OPERATOR: 2804 printf("BL_OPERATOR:"); 2805 delta = 0; 2806 break; 2807 case BLOCK_LAYOUT_NON_OBJECT_BYTES: 2808 printf("BL_NON_OBJECT_BYTES:"); 2809 break; 2810 case BLOCK_LAYOUT_NON_OBJECT_WORDS: 2811 printf("BL_NON_OBJECT_WORD:"); 2812 break; 2813 case BLOCK_LAYOUT_STRONG: 2814 printf("BL_STRONG:"); 2815 break; 2816 case BLOCK_LAYOUT_BYREF: 2817 printf("BL_BYREF:"); 2818 break; 2819 case BLOCK_LAYOUT_WEAK: 2820 printf("BL_WEAK:"); 2821 break; 2822 case BLOCK_LAYOUT_UNRETAINED: 2823 printf("BL_UNRETAINED:"); 2824 break; 2825 } 2826 // Actual value of word count is one more that what is in the imm. 2827 // field of the instruction 2828 printf("%d", (inst & 0xf) + delta); 2829 if (i < e-1) 2830 printf(", "); 2831 else 2832 printf("\n"); 2833 } 2834 } 2835 2836 auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName, 2837 /*ForceNonFragileABI=*/true, 2838 /*NullTerminate=*/false); 2839 return getConstantGEP(VMContext, Entry, 0, 0); 2840 } 2841 2842 static std::string getBlockLayoutInfoString( 2843 const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars, 2844 bool HasCopyDisposeHelpers) { 2845 std::string Str; 2846 for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) { 2847 if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) { 2848 // Copy/dispose helpers don't have any information about 2849 // __unsafe_unretained captures, so unconditionally concatenate a string. 2850 Str += "u"; 2851 } else if (HasCopyDisposeHelpers) { 2852 // Information about __strong, __weak, or byref captures has already been 2853 // encoded into the names of the copy/dispose helpers. We have to add a 2854 // string here only when the copy/dispose helpers aren't generated (which 2855 // happens when the block is non-escaping). 2856 continue; 2857 } else { 2858 switch (R.opcode) { 2859 case CGObjCCommonMac::BLOCK_LAYOUT_STRONG: 2860 Str += "s"; 2861 break; 2862 case CGObjCCommonMac::BLOCK_LAYOUT_BYREF: 2863 Str += "r"; 2864 break; 2865 case CGObjCCommonMac::BLOCK_LAYOUT_WEAK: 2866 Str += "w"; 2867 break; 2868 default: 2869 continue; 2870 } 2871 } 2872 Str += llvm::to_string(R.block_var_bytepos.getQuantity()); 2873 Str += "l" + llvm::to_string(R.block_var_size.getQuantity()); 2874 } 2875 return Str; 2876 } 2877 2878 void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM, 2879 const CGBlockInfo &blockInfo) { 2880 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); 2881 2882 RunSkipBlockVars.clear(); 2883 bool hasUnion = false; 2884 2885 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0); 2886 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); 2887 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits; 2888 2889 const BlockDecl *blockDecl = blockInfo.getBlockDecl(); 2890 2891 // Calculate the basic layout of the block structure. 2892 const llvm::StructLayout *layout = 2893 CGM.getDataLayout().getStructLayout(blockInfo.StructureType); 2894 2895 // Ignore the optional 'this' capture: C++ objects are not assumed 2896 // to be GC'ed. 2897 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero()) 2898 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None, 2899 blockInfo.BlockHeaderForcedGapOffset, 2900 blockInfo.BlockHeaderForcedGapSize); 2901 // Walk the captured variables. 2902 for (const auto &CI : blockDecl->captures()) { 2903 const VarDecl *variable = CI.getVariable(); 2904 QualType type = variable->getType(); 2905 2906 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); 2907 2908 // Ignore constant captures. 2909 if (capture.isConstant()) continue; 2910 2911 CharUnits fieldOffset = 2912 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex())); 2913 2914 assert(!type->isArrayType() && "array variable should not be caught"); 2915 if (!CI.isByRef()) 2916 if (const RecordType *record = type->getAs<RecordType>()) { 2917 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion); 2918 continue; 2919 } 2920 CharUnits fieldSize; 2921 if (CI.isByRef()) 2922 fieldSize = CharUnits::fromQuantity(WordSizeInBytes); 2923 else 2924 fieldSize = CGM.getContext().getTypeSizeInChars(type); 2925 UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false), 2926 fieldOffset, fieldSize); 2927 } 2928 } 2929 2930 llvm::Constant * 2931 CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM, 2932 const CGBlockInfo &blockInfo) { 2933 fillRunSkipBlockVars(CGM, blockInfo); 2934 return getBitmapBlockLayout(false); 2935 } 2936 2937 std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM, 2938 const CGBlockInfo &blockInfo) { 2939 fillRunSkipBlockVars(CGM, blockInfo); 2940 return getBlockLayoutInfoString(RunSkipBlockVars, blockInfo.NeedsCopyDispose); 2941 } 2942 2943 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM, 2944 QualType T) { 2945 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); 2946 assert(!T->isArrayType() && "__block array variable should not be caught"); 2947 CharUnits fieldOffset; 2948 RunSkipBlockVars.clear(); 2949 bool hasUnion = false; 2950 if (const RecordType *record = T->getAs<RecordType>()) { 2951 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */); 2952 llvm::Constant *Result = getBitmapBlockLayout(true); 2953 if (isa<llvm::ConstantInt>(Result)) 2954 Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy); 2955 return Result; 2956 } 2957 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); 2958 return nullPtr; 2959 } 2960 2961 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF, 2962 const ObjCProtocolDecl *PD) { 2963 // FIXME: I don't understand why gcc generates this, or where it is 2964 // resolved. Investigate. Its also wasteful to look this up over and over. 2965 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); 2966 2967 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD), 2968 ObjCTypes.getExternalProtocolPtrTy()); 2969 } 2970 2971 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) { 2972 // FIXME: We shouldn't need this, the protocol decl should contain enough 2973 // information to tell us whether this was a declaration or a definition. 2974 DefinedProtocols.insert(PD->getIdentifier()); 2975 2976 // If we have generated a forward reference to this protocol, emit 2977 // it now. Otherwise do nothing, the protocol objects are lazily 2978 // emitted. 2979 if (Protocols.count(PD->getIdentifier())) 2980 GetOrEmitProtocol(PD); 2981 } 2982 2983 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) { 2984 if (DefinedProtocols.count(PD->getIdentifier())) 2985 return GetOrEmitProtocol(PD); 2986 2987 return GetOrEmitProtocolRef(PD); 2988 } 2989 2990 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime( 2991 CodeGenFunction &CGF, 2992 const ObjCInterfaceDecl *ID, 2993 ObjCCommonTypesHelper &ObjCTypes) { 2994 llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn(); 2995 2996 llvm::Value *className = CGF.CGM 2997 .GetAddrOfConstantCString(std::string( 2998 ID->getObjCRuntimeNameAsString())) 2999 .getPointer(); 3000 ASTContext &ctx = CGF.CGM.getContext(); 3001 className = 3002 CGF.Builder.CreateBitCast(className, 3003 CGF.ConvertType( 3004 ctx.getPointerType(ctx.CharTy.withConst()))); 3005 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className); 3006 call->setDoesNotThrow(); 3007 return call; 3008 } 3009 3010 /* 3011 // Objective-C 1.0 extensions 3012 struct _objc_protocol { 3013 struct _objc_protocol_extension *isa; 3014 char *protocol_name; 3015 struct _objc_protocol_list *protocol_list; 3016 struct _objc__method_prototype_list *instance_methods; 3017 struct _objc__method_prototype_list *class_methods 3018 }; 3019 3020 See EmitProtocolExtension(). 3021 */ 3022 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) { 3023 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()]; 3024 3025 // Early exit if a defining object has already been generated. 3026 if (Entry && Entry->hasInitializer()) 3027 return Entry; 3028 3029 // Use the protocol definition, if there is one. 3030 if (const ObjCProtocolDecl *Def = PD->getDefinition()) 3031 PD = Def; 3032 3033 // FIXME: I don't understand why gcc generates this, or where it is 3034 // resolved. Investigate. Its also wasteful to look this up over and over. 3035 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); 3036 3037 // Construct method lists. 3038 auto methodLists = ProtocolMethodLists::get(PD); 3039 3040 ConstantInitBuilder builder(CGM); 3041 auto values = builder.beginStruct(ObjCTypes.ProtocolTy); 3042 values.add(EmitProtocolExtension(PD, methodLists)); 3043 values.add(GetClassName(PD->getObjCRuntimeNameAsString())); 3044 values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(), 3045 PD->protocol_begin(), PD->protocol_end())); 3046 values.add(methodLists.emitMethodList(this, PD, 3047 ProtocolMethodLists::RequiredInstanceMethods)); 3048 values.add(methodLists.emitMethodList(this, PD, 3049 ProtocolMethodLists::RequiredClassMethods)); 3050 3051 if (Entry) { 3052 // Already created, update the initializer. 3053 assert(Entry->hasPrivateLinkage()); 3054 values.finishAndSetAsInitializer(Entry); 3055 } else { 3056 Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(), 3057 CGM.getPointerAlign(), 3058 /*constant*/ false, 3059 llvm::GlobalValue::PrivateLinkage); 3060 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); 3061 3062 Protocols[PD->getIdentifier()] = Entry; 3063 } 3064 CGM.addCompilerUsedGlobal(Entry); 3065 3066 return Entry; 3067 } 3068 3069 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) { 3070 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 3071 3072 if (!Entry) { 3073 // We use the initializer as a marker of whether this is a forward 3074 // reference or not. At module finalization we add the empty 3075 // contents for protocols which were referenced but never defined. 3076 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, 3077 false, llvm::GlobalValue::PrivateLinkage, 3078 nullptr, "OBJC_PROTOCOL_" + PD->getName()); 3079 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); 3080 // FIXME: Is this necessary? Why only for protocol? 3081 Entry->setAlignment(llvm::Align(4)); 3082 } 3083 3084 return Entry; 3085 } 3086 3087 /* 3088 struct _objc_protocol_extension { 3089 uint32_t size; 3090 struct objc_method_description_list *optional_instance_methods; 3091 struct objc_method_description_list *optional_class_methods; 3092 struct objc_property_list *instance_properties; 3093 const char ** extendedMethodTypes; 3094 struct objc_property_list *class_properties; 3095 }; 3096 */ 3097 llvm::Constant * 3098 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD, 3099 const ProtocolMethodLists &methodLists) { 3100 auto optInstanceMethods = 3101 methodLists.emitMethodList(this, PD, 3102 ProtocolMethodLists::OptionalInstanceMethods); 3103 auto optClassMethods = 3104 methodLists.emitMethodList(this, PD, 3105 ProtocolMethodLists::OptionalClassMethods); 3106 3107 auto extendedMethodTypes = 3108 EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(), 3109 methodLists.emitExtendedTypesArray(this), 3110 ObjCTypes); 3111 3112 auto instanceProperties = 3113 EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD, 3114 ObjCTypes, false); 3115 auto classProperties = 3116 EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr, 3117 PD, ObjCTypes, true); 3118 3119 // Return null if no extension bits are used. 3120 if (optInstanceMethods->isNullValue() && 3121 optClassMethods->isNullValue() && 3122 extendedMethodTypes->isNullValue() && 3123 instanceProperties->isNullValue() && 3124 classProperties->isNullValue()) { 3125 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy); 3126 } 3127 3128 uint64_t size = 3129 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy); 3130 3131 ConstantInitBuilder builder(CGM); 3132 auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy); 3133 values.addInt(ObjCTypes.IntTy, size); 3134 values.add(optInstanceMethods); 3135 values.add(optClassMethods); 3136 values.add(instanceProperties); 3137 values.add(extendedMethodTypes); 3138 values.add(classProperties); 3139 3140 // No special section, but goes in llvm.used 3141 return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values, 3142 StringRef(), CGM.getPointerAlign(), true); 3143 } 3144 3145 /* 3146 struct objc_protocol_list { 3147 struct objc_protocol_list *next; 3148 long count; 3149 Protocol *list[]; 3150 }; 3151 */ 3152 llvm::Constant * 3153 CGObjCMac::EmitProtocolList(Twine name, 3154 ObjCProtocolDecl::protocol_iterator begin, 3155 ObjCProtocolDecl::protocol_iterator end) { 3156 // Just return null for empty protocol lists 3157 auto PDs = GetRuntimeProtocolList(begin, end); 3158 if (PDs.empty()) 3159 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 3160 3161 ConstantInitBuilder builder(CGM); 3162 auto values = builder.beginStruct(); 3163 3164 // This field is only used by the runtime. 3165 values.addNullPointer(ObjCTypes.ProtocolListPtrTy); 3166 3167 // Reserve a slot for the count. 3168 auto countSlot = values.addPlaceholder(); 3169 3170 auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy); 3171 for (const auto *Proto : PDs) 3172 refsArray.add(GetProtocolRef(Proto)); 3173 3174 auto count = refsArray.size(); 3175 3176 // This list is null terminated. 3177 refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy); 3178 3179 refsArray.finishAndAddTo(values); 3180 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count); 3181 3182 StringRef section; 3183 if (CGM.getTriple().isOSBinFormatMachO()) 3184 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; 3185 3186 llvm::GlobalVariable *GV = 3187 CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false); 3188 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy); 3189 } 3190 3191 static void 3192 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet, 3193 SmallVectorImpl<const ObjCPropertyDecl *> &Properties, 3194 const ObjCProtocolDecl *Proto, 3195 bool IsClassProperty) { 3196 for (const auto *PD : Proto->properties()) { 3197 if (IsClassProperty != PD->isClassProperty()) 3198 continue; 3199 if (!PropertySet.insert(PD->getIdentifier()).second) 3200 continue; 3201 Properties.push_back(PD); 3202 } 3203 3204 for (const auto *P : Proto->protocols()) 3205 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); 3206 } 3207 3208 /* 3209 struct _objc_property { 3210 const char * const name; 3211 const char * const attributes; 3212 }; 3213 3214 struct _objc_property_list { 3215 uint32_t entsize; // sizeof (struct _objc_property) 3216 uint32_t prop_count; 3217 struct _objc_property[prop_count]; 3218 }; 3219 */ 3220 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name, 3221 const Decl *Container, 3222 const ObjCContainerDecl *OCD, 3223 const ObjCCommonTypesHelper &ObjCTypes, 3224 bool IsClassProperty) { 3225 if (IsClassProperty) { 3226 // Make this entry NULL for OS X with deployment target < 10.11, for iOS 3227 // with deployment target < 9.0. 3228 const llvm::Triple &Triple = CGM.getTarget().getTriple(); 3229 if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) || 3230 (Triple.isiOS() && Triple.isOSVersionLT(9))) 3231 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 3232 } 3233 3234 SmallVector<const ObjCPropertyDecl *, 16> Properties; 3235 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet; 3236 3237 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) 3238 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions()) 3239 for (auto *PD : ClassExt->properties()) { 3240 if (IsClassProperty != PD->isClassProperty()) 3241 continue; 3242 if (PD->isDirectProperty()) 3243 continue; 3244 PropertySet.insert(PD->getIdentifier()); 3245 Properties.push_back(PD); 3246 } 3247 3248 for (const auto *PD : OCD->properties()) { 3249 if (IsClassProperty != PD->isClassProperty()) 3250 continue; 3251 // Don't emit duplicate metadata for properties that were already in a 3252 // class extension. 3253 if (!PropertySet.insert(PD->getIdentifier()).second) 3254 continue; 3255 if (PD->isDirectProperty()) 3256 continue; 3257 Properties.push_back(PD); 3258 } 3259 3260 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) { 3261 for (const auto *P : OID->all_referenced_protocols()) 3262 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); 3263 } 3264 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) { 3265 for (const auto *P : CD->protocols()) 3266 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); 3267 } 3268 3269 // Return null for empty list. 3270 if (Properties.empty()) 3271 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 3272 3273 unsigned propertySize = 3274 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy); 3275 3276 ConstantInitBuilder builder(CGM); 3277 auto values = builder.beginStruct(); 3278 values.addInt(ObjCTypes.IntTy, propertySize); 3279 values.addInt(ObjCTypes.IntTy, Properties.size()); 3280 auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy); 3281 for (auto PD : Properties) { 3282 auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy); 3283 property.add(GetPropertyName(PD->getIdentifier())); 3284 property.add(GetPropertyTypeString(PD, Container)); 3285 property.finishAndAddTo(propertiesArray); 3286 } 3287 propertiesArray.finishAndAddTo(values); 3288 3289 StringRef Section; 3290 if (CGM.getTriple().isOSBinFormatMachO()) 3291 Section = (ObjCABI == 2) ? "__DATA, __objc_const" 3292 : "__OBJC,__property,regular,no_dead_strip"; 3293 3294 llvm::GlobalVariable *GV = 3295 CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true); 3296 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy); 3297 } 3298 3299 llvm::Constant * 3300 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name, 3301 ArrayRef<llvm::Constant*> MethodTypes, 3302 const ObjCCommonTypesHelper &ObjCTypes) { 3303 // Return null for empty list. 3304 if (MethodTypes.empty()) 3305 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy); 3306 3307 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, 3308 MethodTypes.size()); 3309 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes); 3310 3311 StringRef Section; 3312 if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2) 3313 Section = "__DATA, __objc_const"; 3314 3315 llvm::GlobalVariable *GV = 3316 CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true); 3317 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy); 3318 } 3319 3320 /* 3321 struct _objc_category { 3322 char *category_name; 3323 char *class_name; 3324 struct _objc_method_list *instance_methods; 3325 struct _objc_method_list *class_methods; 3326 struct _objc_protocol_list *protocols; 3327 uint32_t size; // <rdar://4585769> 3328 struct _objc_property_list *instance_properties; 3329 struct _objc_property_list *class_properties; 3330 }; 3331 */ 3332 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) { 3333 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy); 3334 3335 // FIXME: This is poor design, the OCD should have a pointer to the category 3336 // decl. Additionally, note that Category can be null for the @implementation 3337 // w/o an @interface case. Sema should just create one for us as it does for 3338 // @implementation so everyone else can live life under a clear blue sky. 3339 const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); 3340 const ObjCCategoryDecl *Category = 3341 Interface->FindCategoryDeclaration(OCD->getIdentifier()); 3342 3343 SmallString<256> ExtName; 3344 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_' 3345 << OCD->getName(); 3346 3347 ConstantInitBuilder Builder(CGM); 3348 auto Values = Builder.beginStruct(ObjCTypes.CategoryTy); 3349 3350 enum { 3351 InstanceMethods, 3352 ClassMethods, 3353 NumMethodLists 3354 }; 3355 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists]; 3356 for (const auto *MD : OCD->methods()) { 3357 if (!MD->isDirectMethod()) 3358 Methods[unsigned(MD->isClassMethod())].push_back(MD); 3359 } 3360 3361 Values.add(GetClassName(OCD->getName())); 3362 Values.add(GetClassName(Interface->getObjCRuntimeNameAsString())); 3363 LazySymbols.insert(Interface->getIdentifier()); 3364 3365 Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods, 3366 Methods[InstanceMethods])); 3367 Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods, 3368 Methods[ClassMethods])); 3369 if (Category) { 3370 Values.add( 3371 EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(), 3372 Category->protocol_begin(), Category->protocol_end())); 3373 } else { 3374 Values.addNullPointer(ObjCTypes.ProtocolListPtrTy); 3375 } 3376 Values.addInt(ObjCTypes.IntTy, Size); 3377 3378 // If there is no category @interface then there can be no properties. 3379 if (Category) { 3380 Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(), 3381 OCD, Category, ObjCTypes, false)); 3382 Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(), 3383 OCD, Category, ObjCTypes, true)); 3384 } else { 3385 Values.addNullPointer(ObjCTypes.PropertyListPtrTy); 3386 Values.addNullPointer(ObjCTypes.PropertyListPtrTy); 3387 } 3388 3389 llvm::GlobalVariable *GV = 3390 CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values, 3391 "__OBJC,__category,regular,no_dead_strip", 3392 CGM.getPointerAlign(), true); 3393 DefinedCategories.push_back(GV); 3394 DefinedCategoryNames.insert(llvm::CachedHashString(ExtName)); 3395 // method definition entries must be clear for next implementation. 3396 MethodDefinitions.clear(); 3397 } 3398 3399 enum FragileClassFlags { 3400 /// Apparently: is not a meta-class. 3401 FragileABI_Class_Factory = 0x00001, 3402 3403 /// Is a meta-class. 3404 FragileABI_Class_Meta = 0x00002, 3405 3406 /// Has a non-trivial constructor or destructor. 3407 FragileABI_Class_HasCXXStructors = 0x02000, 3408 3409 /// Has hidden visibility. 3410 FragileABI_Class_Hidden = 0x20000, 3411 3412 /// Class implementation was compiled under ARC. 3413 FragileABI_Class_CompiledByARC = 0x04000000, 3414 3415 /// Class implementation was compiled under MRC and has MRC weak ivars. 3416 /// Exclusive with CompiledByARC. 3417 FragileABI_Class_HasMRCWeakIvars = 0x08000000, 3418 }; 3419 3420 enum NonFragileClassFlags { 3421 /// Is a meta-class. 3422 NonFragileABI_Class_Meta = 0x00001, 3423 3424 /// Is a root class. 3425 NonFragileABI_Class_Root = 0x00002, 3426 3427 /// Has a non-trivial constructor or destructor. 3428 NonFragileABI_Class_HasCXXStructors = 0x00004, 3429 3430 /// Has hidden visibility. 3431 NonFragileABI_Class_Hidden = 0x00010, 3432 3433 /// Has the exception attribute. 3434 NonFragileABI_Class_Exception = 0x00020, 3435 3436 /// (Obsolete) ARC-specific: this class has a .release_ivars method 3437 NonFragileABI_Class_HasIvarReleaser = 0x00040, 3438 3439 /// Class implementation was compiled under ARC. 3440 NonFragileABI_Class_CompiledByARC = 0x00080, 3441 3442 /// Class has non-trivial destructors, but zero-initialization is okay. 3443 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100, 3444 3445 /// Class implementation was compiled under MRC and has MRC weak ivars. 3446 /// Exclusive with CompiledByARC. 3447 NonFragileABI_Class_HasMRCWeakIvars = 0x00200, 3448 }; 3449 3450 static bool hasWeakMember(QualType type) { 3451 if (type.getObjCLifetime() == Qualifiers::OCL_Weak) { 3452 return true; 3453 } 3454 3455 if (auto recType = type->getAs<RecordType>()) { 3456 for (auto field : recType->getDecl()->fields()) { 3457 if (hasWeakMember(field->getType())) 3458 return true; 3459 } 3460 } 3461 3462 return false; 3463 } 3464 3465 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag 3466 /// (and actually fill in a layout string) if we really do have any 3467 /// __weak ivars. 3468 static bool hasMRCWeakIvars(CodeGenModule &CGM, 3469 const ObjCImplementationDecl *ID) { 3470 if (!CGM.getLangOpts().ObjCWeak) return false; 3471 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); 3472 3473 for (const ObjCIvarDecl *ivar = 3474 ID->getClassInterface()->all_declared_ivar_begin(); 3475 ivar; ivar = ivar->getNextIvar()) { 3476 if (hasWeakMember(ivar->getType())) 3477 return true; 3478 } 3479 3480 return false; 3481 } 3482 3483 /* 3484 struct _objc_class { 3485 Class isa; 3486 Class super_class; 3487 const char *name; 3488 long version; 3489 long info; 3490 long instance_size; 3491 struct _objc_ivar_list *ivars; 3492 struct _objc_method_list *methods; 3493 struct _objc_cache *cache; 3494 struct _objc_protocol_list *protocols; 3495 // Objective-C 1.0 extensions (<rdr://4585769>) 3496 const char *ivar_layout; 3497 struct _objc_class_ext *ext; 3498 }; 3499 3500 See EmitClassExtension(); 3501 */ 3502 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) { 3503 IdentifierInfo *RuntimeName = 3504 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString()); 3505 DefinedSymbols.insert(RuntimeName); 3506 3507 std::string ClassName = ID->getNameAsString(); 3508 // FIXME: Gross 3509 ObjCInterfaceDecl *Interface = 3510 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface()); 3511 llvm::Constant *Protocols = 3512 EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(), 3513 Interface->all_referenced_protocol_begin(), 3514 Interface->all_referenced_protocol_end()); 3515 unsigned Flags = FragileABI_Class_Factory; 3516 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) 3517 Flags |= FragileABI_Class_HasCXXStructors; 3518 3519 bool hasMRCWeak = false; 3520 3521 if (CGM.getLangOpts().ObjCAutoRefCount) 3522 Flags |= FragileABI_Class_CompiledByARC; 3523 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID))) 3524 Flags |= FragileABI_Class_HasMRCWeakIvars; 3525 3526 CharUnits Size = 3527 CGM.getContext().getASTObjCImplementationLayout(ID).getSize(); 3528 3529 // FIXME: Set CXX-structors flag. 3530 if (ID->getClassInterface()->getVisibility() == HiddenVisibility) 3531 Flags |= FragileABI_Class_Hidden; 3532 3533 enum { 3534 InstanceMethods, 3535 ClassMethods, 3536 NumMethodLists 3537 }; 3538 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists]; 3539 for (const auto *MD : ID->methods()) { 3540 if (!MD->isDirectMethod()) 3541 Methods[unsigned(MD->isClassMethod())].push_back(MD); 3542 } 3543 3544 for (const auto *PID : ID->property_impls()) { 3545 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 3546 if (PID->getPropertyDecl()->isDirectProperty()) 3547 continue; 3548 if (ObjCMethodDecl *MD = PID->getGetterMethodDecl()) 3549 if (GetMethodDefinition(MD)) 3550 Methods[InstanceMethods].push_back(MD); 3551 if (ObjCMethodDecl *MD = PID->getSetterMethodDecl()) 3552 if (GetMethodDefinition(MD)) 3553 Methods[InstanceMethods].push_back(MD); 3554 } 3555 } 3556 3557 ConstantInitBuilder builder(CGM); 3558 auto values = builder.beginStruct(ObjCTypes.ClassTy); 3559 values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods])); 3560 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) { 3561 // Record a reference to the super class. 3562 LazySymbols.insert(Super->getIdentifier()); 3563 3564 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()), 3565 ObjCTypes.ClassPtrTy); 3566 } else { 3567 values.addNullPointer(ObjCTypes.ClassPtrTy); 3568 } 3569 values.add(GetClassName(ID->getObjCRuntimeNameAsString())); 3570 // Version is always 0. 3571 values.addInt(ObjCTypes.LongTy, 0); 3572 values.addInt(ObjCTypes.LongTy, Flags); 3573 values.addInt(ObjCTypes.LongTy, Size.getQuantity()); 3574 values.add(EmitIvarList(ID, false)); 3575 values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods, 3576 Methods[InstanceMethods])); 3577 // cache is always NULL. 3578 values.addNullPointer(ObjCTypes.CachePtrTy); 3579 values.add(Protocols); 3580 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size)); 3581 values.add(EmitClassExtension(ID, Size, hasMRCWeak, 3582 /*isMetaclass*/ false)); 3583 3584 std::string Name("OBJC_CLASS_"); 3585 Name += ClassName; 3586 const char *Section = "__OBJC,__class,regular,no_dead_strip"; 3587 // Check for a forward reference. 3588 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); 3589 if (GV) { 3590 assert(GV->getValueType() == ObjCTypes.ClassTy && 3591 "Forward metaclass reference has incorrect type."); 3592 values.finishAndSetAsInitializer(GV); 3593 GV->setSection(Section); 3594 GV->setAlignment(CGM.getPointerAlign().getAsAlign()); 3595 CGM.addCompilerUsedGlobal(GV); 3596 } else 3597 GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true); 3598 DefinedClasses.push_back(GV); 3599 ImplementedClasses.push_back(Interface); 3600 // method definition entries must be clear for next implementation. 3601 MethodDefinitions.clear(); 3602 } 3603 3604 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID, 3605 llvm::Constant *Protocols, 3606 ArrayRef<const ObjCMethodDecl*> Methods) { 3607 unsigned Flags = FragileABI_Class_Meta; 3608 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy); 3609 3610 if (ID->getClassInterface()->getVisibility() == HiddenVisibility) 3611 Flags |= FragileABI_Class_Hidden; 3612 3613 ConstantInitBuilder builder(CGM); 3614 auto values = builder.beginStruct(ObjCTypes.ClassTy); 3615 // The isa for the metaclass is the root of the hierarchy. 3616 const ObjCInterfaceDecl *Root = ID->getClassInterface(); 3617 while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) 3618 Root = Super; 3619 values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()), 3620 ObjCTypes.ClassPtrTy); 3621 // The super class for the metaclass is emitted as the name of the 3622 // super class. The runtime fixes this up to point to the 3623 // *metaclass* for the super class. 3624 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) { 3625 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()), 3626 ObjCTypes.ClassPtrTy); 3627 } else { 3628 values.addNullPointer(ObjCTypes.ClassPtrTy); 3629 } 3630 values.add(GetClassName(ID->getObjCRuntimeNameAsString())); 3631 // Version is always 0. 3632 values.addInt(ObjCTypes.LongTy, 0); 3633 values.addInt(ObjCTypes.LongTy, Flags); 3634 values.addInt(ObjCTypes.LongTy, Size); 3635 values.add(EmitIvarList(ID, true)); 3636 values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods, 3637 Methods)); 3638 // cache is always NULL. 3639 values.addNullPointer(ObjCTypes.CachePtrTy); 3640 values.add(Protocols); 3641 // ivar_layout for metaclass is always NULL. 3642 values.addNullPointer(ObjCTypes.Int8PtrTy); 3643 // The class extension is used to store class properties for metaclasses. 3644 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/, 3645 /*isMetaclass*/true)); 3646 3647 std::string Name("OBJC_METACLASS_"); 3648 Name += ID->getName(); 3649 3650 // Check for a forward reference. 3651 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); 3652 if (GV) { 3653 assert(GV->getValueType() == ObjCTypes.ClassTy && 3654 "Forward metaclass reference has incorrect type."); 3655 values.finishAndSetAsInitializer(GV); 3656 } else { 3657 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(), 3658 /*constant*/ false, 3659 llvm::GlobalValue::PrivateLinkage); 3660 } 3661 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip"); 3662 CGM.addCompilerUsedGlobal(GV); 3663 3664 return GV; 3665 } 3666 3667 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) { 3668 std::string Name = "OBJC_METACLASS_" + ID->getNameAsString(); 3669 3670 // FIXME: Should we look these up somewhere other than the module. Its a bit 3671 // silly since we only generate these while processing an implementation, so 3672 // exactly one pointer would work if know when we entered/exitted an 3673 // implementation block. 3674 3675 // Check for an existing forward reference. 3676 // Previously, metaclass with internal linkage may have been defined. 3677 // pass 'true' as 2nd argument so it is returned. 3678 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); 3679 if (!GV) 3680 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false, 3681 llvm::GlobalValue::PrivateLinkage, nullptr, 3682 Name); 3683 3684 assert(GV->getValueType() == ObjCTypes.ClassTy && 3685 "Forward metaclass reference has incorrect type."); 3686 return GV; 3687 } 3688 3689 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) { 3690 std::string Name = "OBJC_CLASS_" + ID->getNameAsString(); 3691 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); 3692 3693 if (!GV) 3694 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false, 3695 llvm::GlobalValue::PrivateLinkage, nullptr, 3696 Name); 3697 3698 assert(GV->getValueType() == ObjCTypes.ClassTy && 3699 "Forward class metadata reference has incorrect type."); 3700 return GV; 3701 } 3702 3703 /* 3704 Emit a "class extension", which in this specific context means extra 3705 data that doesn't fit in the normal fragile-ABI class structure, and 3706 has nothing to do with the language concept of a class extension. 3707 3708 struct objc_class_ext { 3709 uint32_t size; 3710 const char *weak_ivar_layout; 3711 struct _objc_property_list *properties; 3712 }; 3713 */ 3714 llvm::Constant * 3715 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID, 3716 CharUnits InstanceSize, bool hasMRCWeakIvars, 3717 bool isMetaclass) { 3718 // Weak ivar layout. 3719 llvm::Constant *layout; 3720 if (isMetaclass) { 3721 layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy); 3722 } else { 3723 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize, 3724 hasMRCWeakIvars); 3725 } 3726 3727 // Properties. 3728 llvm::Constant *propertyList = 3729 EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_") 3730 : Twine("_OBJC_$_PROP_LIST_")) 3731 + ID->getName(), 3732 ID, ID->getClassInterface(), ObjCTypes, isMetaclass); 3733 3734 // Return null if no extension bits are used. 3735 if (layout->isNullValue() && propertyList->isNullValue()) { 3736 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy); 3737 } 3738 3739 uint64_t size = 3740 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy); 3741 3742 ConstantInitBuilder builder(CGM); 3743 auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy); 3744 values.addInt(ObjCTypes.IntTy, size); 3745 values.add(layout); 3746 values.add(propertyList); 3747 3748 return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values, 3749 "__OBJC,__class_ext,regular,no_dead_strip", 3750 CGM.getPointerAlign(), true); 3751 } 3752 3753 /* 3754 struct objc_ivar { 3755 char *ivar_name; 3756 char *ivar_type; 3757 int ivar_offset; 3758 }; 3759 3760 struct objc_ivar_list { 3761 int ivar_count; 3762 struct objc_ivar list[count]; 3763 }; 3764 */ 3765 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID, 3766 bool ForClass) { 3767 // When emitting the root class GCC emits ivar entries for the 3768 // actual class structure. It is not clear if we need to follow this 3769 // behavior; for now lets try and get away with not doing it. If so, 3770 // the cleanest solution would be to make up an ObjCInterfaceDecl 3771 // for the class. 3772 if (ForClass) 3773 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); 3774 3775 const ObjCInterfaceDecl *OID = ID->getClassInterface(); 3776 3777 ConstantInitBuilder builder(CGM); 3778 auto ivarList = builder.beginStruct(); 3779 auto countSlot = ivarList.addPlaceholder(); 3780 auto ivars = ivarList.beginArray(ObjCTypes.IvarTy); 3781 3782 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin(); 3783 IVD; IVD = IVD->getNextIvar()) { 3784 // Ignore unnamed bit-fields. 3785 if (!IVD->getDeclName()) 3786 continue; 3787 3788 auto ivar = ivars.beginStruct(ObjCTypes.IvarTy); 3789 ivar.add(GetMethodVarName(IVD->getIdentifier())); 3790 ivar.add(GetMethodVarType(IVD)); 3791 ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD)); 3792 ivar.finishAndAddTo(ivars); 3793 } 3794 3795 // Return null for empty list. 3796 auto count = ivars.size(); 3797 if (count == 0) { 3798 ivars.abandon(); 3799 ivarList.abandon(); 3800 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); 3801 } 3802 3803 ivars.finishAndAddTo(ivarList); 3804 ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count); 3805 3806 llvm::GlobalVariable *GV; 3807 if (ForClass) 3808 GV = 3809 CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList, 3810 "__OBJC,__class_vars,regular,no_dead_strip", 3811 CGM.getPointerAlign(), true); 3812 else 3813 GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList, 3814 "__OBJC,__instance_vars,regular,no_dead_strip", 3815 CGM.getPointerAlign(), true); 3816 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy); 3817 } 3818 3819 /// Build a struct objc_method_description constant for the given method. 3820 /// 3821 /// struct objc_method_description { 3822 /// SEL method_name; 3823 /// char *method_types; 3824 /// }; 3825 void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder, 3826 const ObjCMethodDecl *MD) { 3827 auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy); 3828 description.addBitCast(GetMethodVarName(MD->getSelector()), 3829 ObjCTypes.SelectorPtrTy); 3830 description.add(GetMethodVarType(MD)); 3831 description.finishAndAddTo(builder); 3832 } 3833 3834 /// Build a struct objc_method constant for the given method. 3835 /// 3836 /// struct objc_method { 3837 /// SEL method_name; 3838 /// char *method_types; 3839 /// void *method; 3840 /// }; 3841 void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder, 3842 const ObjCMethodDecl *MD) { 3843 llvm::Function *fn = GetMethodDefinition(MD); 3844 assert(fn && "no definition registered for method"); 3845 3846 auto method = builder.beginStruct(ObjCTypes.MethodTy); 3847 method.addBitCast(GetMethodVarName(MD->getSelector()), 3848 ObjCTypes.SelectorPtrTy); 3849 method.add(GetMethodVarType(MD)); 3850 method.addBitCast(fn, ObjCTypes.Int8PtrTy); 3851 method.finishAndAddTo(builder); 3852 } 3853 3854 /// Build a struct objc_method_list or struct objc_method_description_list, 3855 /// as appropriate. 3856 /// 3857 /// struct objc_method_list { 3858 /// struct objc_method_list *obsolete; 3859 /// int count; 3860 /// struct objc_method methods_list[count]; 3861 /// }; 3862 /// 3863 /// struct objc_method_description_list { 3864 /// int count; 3865 /// struct objc_method_description list[count]; 3866 /// }; 3867 llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT, 3868 ArrayRef<const ObjCMethodDecl *> methods) { 3869 StringRef prefix; 3870 StringRef section; 3871 bool forProtocol = false; 3872 switch (MLT) { 3873 case MethodListType::CategoryInstanceMethods: 3874 prefix = "OBJC_CATEGORY_INSTANCE_METHODS_"; 3875 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; 3876 forProtocol = false; 3877 break; 3878 case MethodListType::CategoryClassMethods: 3879 prefix = "OBJC_CATEGORY_CLASS_METHODS_"; 3880 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; 3881 forProtocol = false; 3882 break; 3883 case MethodListType::InstanceMethods: 3884 prefix = "OBJC_INSTANCE_METHODS_"; 3885 section = "__OBJC,__inst_meth,regular,no_dead_strip"; 3886 forProtocol = false; 3887 break; 3888 case MethodListType::ClassMethods: 3889 prefix = "OBJC_CLASS_METHODS_"; 3890 section = "__OBJC,__cls_meth,regular,no_dead_strip"; 3891 forProtocol = false; 3892 break; 3893 case MethodListType::ProtocolInstanceMethods: 3894 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_"; 3895 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; 3896 forProtocol = true; 3897 break; 3898 case MethodListType::ProtocolClassMethods: 3899 prefix = "OBJC_PROTOCOL_CLASS_METHODS_"; 3900 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; 3901 forProtocol = true; 3902 break; 3903 case MethodListType::OptionalProtocolInstanceMethods: 3904 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_"; 3905 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; 3906 forProtocol = true; 3907 break; 3908 case MethodListType::OptionalProtocolClassMethods: 3909 prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_"; 3910 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; 3911 forProtocol = true; 3912 break; 3913 } 3914 3915 // Return null for empty list. 3916 if (methods.empty()) 3917 return llvm::Constant::getNullValue(forProtocol 3918 ? ObjCTypes.MethodDescriptionListPtrTy 3919 : ObjCTypes.MethodListPtrTy); 3920 3921 // For protocols, this is an objc_method_description_list, which has 3922 // a slightly different structure. 3923 if (forProtocol) { 3924 ConstantInitBuilder builder(CGM); 3925 auto values = builder.beginStruct(); 3926 values.addInt(ObjCTypes.IntTy, methods.size()); 3927 auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy); 3928 for (auto MD : methods) { 3929 emitMethodDescriptionConstant(methodArray, MD); 3930 } 3931 methodArray.finishAndAddTo(values); 3932 3933 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section, 3934 CGM.getPointerAlign(), true); 3935 return llvm::ConstantExpr::getBitCast(GV, 3936 ObjCTypes.MethodDescriptionListPtrTy); 3937 } 3938 3939 // Otherwise, it's an objc_method_list. 3940 ConstantInitBuilder builder(CGM); 3941 auto values = builder.beginStruct(); 3942 values.addNullPointer(ObjCTypes.Int8PtrTy); 3943 values.addInt(ObjCTypes.IntTy, methods.size()); 3944 auto methodArray = values.beginArray(ObjCTypes.MethodTy); 3945 for (auto MD : methods) { 3946 if (!MD->isDirectMethod()) 3947 emitMethodConstant(methodArray, MD); 3948 } 3949 methodArray.finishAndAddTo(values); 3950 3951 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section, 3952 CGM.getPointerAlign(), true); 3953 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy); 3954 } 3955 3956 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD, 3957 const ObjCContainerDecl *CD) { 3958 llvm::Function *Method; 3959 3960 if (OMD->isDirectMethod()) { 3961 Method = GenerateDirectMethod(OMD, CD); 3962 } else { 3963 auto Name = getSymbolNameForMethod(OMD); 3964 3965 CodeGenTypes &Types = CGM.getTypes(); 3966 llvm::FunctionType *MethodTy = 3967 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD)); 3968 Method = 3969 llvm::Function::Create(MethodTy, llvm::GlobalValue::InternalLinkage, 3970 Name, &CGM.getModule()); 3971 } 3972 3973 MethodDefinitions.insert(std::make_pair(OMD, Method)); 3974 3975 return Method; 3976 } 3977 3978 llvm::Function * 3979 CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD, 3980 const ObjCContainerDecl *CD) { 3981 auto *COMD = OMD->getCanonicalDecl(); 3982 auto I = DirectMethodDefinitions.find(COMD); 3983 llvm::Function *OldFn = nullptr, *Fn = nullptr; 3984 3985 if (I != DirectMethodDefinitions.end()) { 3986 // Objective-C allows for the declaration and implementation types 3987 // to differ slightly. 3988 // 3989 // If we're being asked for the Function associated for a method 3990 // implementation, a previous value might have been cached 3991 // based on the type of the canonical declaration. 3992 // 3993 // If these do not match, then we'll replace this function with 3994 // a new one that has the proper type below. 3995 if (!OMD->getBody() || COMD->getReturnType() == OMD->getReturnType()) 3996 return I->second; 3997 OldFn = I->second; 3998 } 3999 4000 CodeGenTypes &Types = CGM.getTypes(); 4001 llvm::FunctionType *MethodTy = 4002 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD)); 4003 4004 if (OldFn) { 4005 Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage, 4006 "", &CGM.getModule()); 4007 Fn->takeName(OldFn); 4008 OldFn->replaceAllUsesWith( 4009 llvm::ConstantExpr::getBitCast(Fn, OldFn->getType())); 4010 OldFn->eraseFromParent(); 4011 4012 // Replace the cached function in the map. 4013 I->second = Fn; 4014 } else { 4015 auto Name = getSymbolNameForMethod(OMD, /*include category*/ false); 4016 4017 Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage, 4018 Name, &CGM.getModule()); 4019 DirectMethodDefinitions.insert(std::make_pair(COMD, Fn)); 4020 } 4021 4022 return Fn; 4023 } 4024 4025 void CGObjCCommonMac::GenerateDirectMethodPrologue( 4026 CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD, 4027 const ObjCContainerDecl *CD) { 4028 auto &Builder = CGF.Builder; 4029 bool ReceiverCanBeNull = true; 4030 auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl()); 4031 auto selfValue = Builder.CreateLoad(selfAddr); 4032 4033 // Generate: 4034 // 4035 // /* for class methods only to force class lazy initialization */ 4036 // self = [self self]; 4037 // 4038 // /* unless the receiver is never NULL */ 4039 // if (self == nil) { 4040 // return (ReturnType){ }; 4041 // } 4042 // 4043 // _cmd = @selector(...) 4044 // ... 4045 4046 if (OMD->isClassMethod()) { 4047 const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD); 4048 assert(OID && 4049 "GenerateDirectMethod() should be called with the Class Interface"); 4050 Selector SelfSel = GetNullarySelector("self", CGM.getContext()); 4051 auto ResultType = CGF.getContext().getObjCIdType(); 4052 RValue result; 4053 CallArgList Args; 4054 4055 // TODO: If this method is inlined, the caller might know that `self` is 4056 // already initialized; for example, it might be an ordinary Objective-C 4057 // method which always receives an initialized `self`, or it might have just 4058 // forced initialization on its own. 4059 // 4060 // We should find a way to eliminate this unnecessary initialization in such 4061 // cases in LLVM. 4062 result = GeneratePossiblySpecializedMessageSend( 4063 CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID, 4064 nullptr, true); 4065 Builder.CreateStore(result.getScalarVal(), selfAddr); 4066 4067 // Nullable `Class` expressions cannot be messaged with a direct method 4068 // so the only reason why the receive can be null would be because 4069 // of weak linking. 4070 ReceiverCanBeNull = isWeakLinkedClass(OID); 4071 } 4072 4073 if (ReceiverCanBeNull) { 4074 llvm::BasicBlock *SelfIsNilBlock = 4075 CGF.createBasicBlock("objc_direct_method.self_is_nil"); 4076 llvm::BasicBlock *ContBlock = 4077 CGF.createBasicBlock("objc_direct_method.cont"); 4078 4079 // if (self == nil) { 4080 auto selfTy = cast<llvm::PointerType>(selfValue->getType()); 4081 auto Zero = llvm::ConstantPointerNull::get(selfTy); 4082 4083 llvm::MDBuilder MDHelper(CGM.getLLVMContext()); 4084 Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock, 4085 ContBlock, MDHelper.createBranchWeights(1, 1 << 20)); 4086 4087 CGF.EmitBlock(SelfIsNilBlock); 4088 4089 // return (ReturnType){ }; 4090 auto retTy = OMD->getReturnType(); 4091 Builder.SetInsertPoint(SelfIsNilBlock); 4092 if (!retTy->isVoidType()) { 4093 CGF.EmitNullInitialization(CGF.ReturnValue, retTy); 4094 } 4095 CGF.EmitBranchThroughCleanup(CGF.ReturnBlock); 4096 // } 4097 4098 // rest of the body 4099 CGF.EmitBlock(ContBlock); 4100 Builder.SetInsertPoint(ContBlock); 4101 } 4102 4103 // only synthesize _cmd if it's referenced 4104 if (OMD->getCmdDecl()->isUsed()) { 4105 Builder.CreateStore(GetSelector(CGF, OMD), 4106 CGF.GetAddrOfLocalVar(OMD->getCmdDecl())); 4107 } 4108 } 4109 4110 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name, 4111 ConstantStructBuilder &Init, 4112 StringRef Section, 4113 CharUnits Align, 4114 bool AddToUsed) { 4115 llvm::GlobalValue::LinkageTypes LT = 4116 getLinkageTypeForObjCMetadata(CGM, Section); 4117 llvm::GlobalVariable *GV = 4118 Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT); 4119 if (!Section.empty()) 4120 GV->setSection(Section); 4121 if (AddToUsed) 4122 CGM.addCompilerUsedGlobal(GV); 4123 return GV; 4124 } 4125 4126 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name, 4127 llvm::Constant *Init, 4128 StringRef Section, 4129 CharUnits Align, 4130 bool AddToUsed) { 4131 llvm::Type *Ty = Init->getType(); 4132 llvm::GlobalValue::LinkageTypes LT = 4133 getLinkageTypeForObjCMetadata(CGM, Section); 4134 llvm::GlobalVariable *GV = 4135 new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name); 4136 if (!Section.empty()) 4137 GV->setSection(Section); 4138 GV->setAlignment(Align.getAsAlign()); 4139 if (AddToUsed) 4140 CGM.addCompilerUsedGlobal(GV); 4141 return GV; 4142 } 4143 4144 llvm::GlobalVariable * 4145 CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type, 4146 bool ForceNonFragileABI, 4147 bool NullTerminate) { 4148 StringRef Label; 4149 switch (Type) { 4150 case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break; 4151 case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break; 4152 case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break; 4153 case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break; 4154 } 4155 4156 bool NonFragile = ForceNonFragileABI || isNonFragileABI(); 4157 4158 StringRef Section; 4159 switch (Type) { 4160 case ObjCLabelType::ClassName: 4161 Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals" 4162 : "__TEXT,__cstring,cstring_literals"; 4163 break; 4164 case ObjCLabelType::MethodVarName: 4165 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals" 4166 : "__TEXT,__cstring,cstring_literals"; 4167 break; 4168 case ObjCLabelType::MethodVarType: 4169 Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals" 4170 : "__TEXT,__cstring,cstring_literals"; 4171 break; 4172 case ObjCLabelType::PropertyName: 4173 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals" 4174 : "__TEXT,__cstring,cstring_literals"; 4175 break; 4176 } 4177 4178 llvm::Constant *Value = 4179 llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate); 4180 llvm::GlobalVariable *GV = 4181 new llvm::GlobalVariable(CGM.getModule(), Value->getType(), 4182 /*isConstant=*/true, 4183 llvm::GlobalValue::PrivateLinkage, Value, Label); 4184 if (CGM.getTriple().isOSBinFormatMachO()) 4185 GV->setSection(Section); 4186 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 4187 GV->setAlignment(CharUnits::One().getAsAlign()); 4188 CGM.addCompilerUsedGlobal(GV); 4189 4190 return GV; 4191 } 4192 4193 llvm::Function *CGObjCMac::ModuleInitFunction() { 4194 // Abuse this interface function as a place to finalize. 4195 FinishModule(); 4196 return nullptr; 4197 } 4198 4199 llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() { 4200 return ObjCTypes.getGetPropertyFn(); 4201 } 4202 4203 llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() { 4204 return ObjCTypes.getSetPropertyFn(); 4205 } 4206 4207 llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic, 4208 bool copy) { 4209 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy); 4210 } 4211 4212 llvm::FunctionCallee CGObjCMac::GetGetStructFunction() { 4213 return ObjCTypes.getCopyStructFn(); 4214 } 4215 4216 llvm::FunctionCallee CGObjCMac::GetSetStructFunction() { 4217 return ObjCTypes.getCopyStructFn(); 4218 } 4219 4220 llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() { 4221 return ObjCTypes.getCppAtomicObjectFunction(); 4222 } 4223 4224 llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() { 4225 return ObjCTypes.getCppAtomicObjectFunction(); 4226 } 4227 4228 llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() { 4229 return ObjCTypes.getEnumerationMutationFn(); 4230 } 4231 4232 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) { 4233 return EmitTryOrSynchronizedStmt(CGF, S); 4234 } 4235 4236 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF, 4237 const ObjCAtSynchronizedStmt &S) { 4238 return EmitTryOrSynchronizedStmt(CGF, S); 4239 } 4240 4241 namespace { 4242 struct PerformFragileFinally final : EHScopeStack::Cleanup { 4243 const Stmt &S; 4244 Address SyncArgSlot; 4245 Address CallTryExitVar; 4246 Address ExceptionData; 4247 ObjCTypesHelper &ObjCTypes; 4248 PerformFragileFinally(const Stmt *S, 4249 Address SyncArgSlot, 4250 Address CallTryExitVar, 4251 Address ExceptionData, 4252 ObjCTypesHelper *ObjCTypes) 4253 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar), 4254 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {} 4255 4256 void Emit(CodeGenFunction &CGF, Flags flags) override { 4257 // Check whether we need to call objc_exception_try_exit. 4258 // In optimized code, this branch will always be folded. 4259 llvm::BasicBlock *FinallyCallExit = 4260 CGF.createBasicBlock("finally.call_exit"); 4261 llvm::BasicBlock *FinallyNoCallExit = 4262 CGF.createBasicBlock("finally.no_call_exit"); 4263 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar), 4264 FinallyCallExit, FinallyNoCallExit); 4265 4266 CGF.EmitBlock(FinallyCallExit); 4267 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(), 4268 ExceptionData.getPointer()); 4269 4270 CGF.EmitBlock(FinallyNoCallExit); 4271 4272 if (isa<ObjCAtTryStmt>(S)) { 4273 if (const ObjCAtFinallyStmt* FinallyStmt = 4274 cast<ObjCAtTryStmt>(S).getFinallyStmt()) { 4275 // Don't try to do the @finally if this is an EH cleanup. 4276 if (flags.isForEHCleanup()) return; 4277 4278 // Save the current cleanup destination in case there's 4279 // control flow inside the finally statement. 4280 llvm::Value *CurCleanupDest = 4281 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot()); 4282 4283 CGF.EmitStmt(FinallyStmt->getFinallyBody()); 4284 4285 if (CGF.HaveInsertPoint()) { 4286 CGF.Builder.CreateStore(CurCleanupDest, 4287 CGF.getNormalCleanupDestSlot()); 4288 } else { 4289 // Currently, the end of the cleanup must always exist. 4290 CGF.EnsureInsertPoint(); 4291 } 4292 } 4293 } else { 4294 // Emit objc_sync_exit(expr); as finally's sole statement for 4295 // @synchronized. 4296 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot); 4297 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg); 4298 } 4299 } 4300 }; 4301 4302 class FragileHazards { 4303 CodeGenFunction &CGF; 4304 SmallVector<llvm::Value*, 20> Locals; 4305 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry; 4306 4307 llvm::InlineAsm *ReadHazard; 4308 llvm::InlineAsm *WriteHazard; 4309 4310 llvm::FunctionType *GetAsmFnType(); 4311 4312 void collectLocals(); 4313 void emitReadHazard(CGBuilderTy &Builder); 4314 4315 public: 4316 FragileHazards(CodeGenFunction &CGF); 4317 4318 void emitWriteHazard(); 4319 void emitHazardsInNewBlocks(); 4320 }; 4321 } // end anonymous namespace 4322 4323 /// Create the fragile-ABI read and write hazards based on the current 4324 /// state of the function, which is presumed to be immediately prior 4325 /// to a @try block. These hazards are used to maintain correct 4326 /// semantics in the face of optimization and the fragile ABI's 4327 /// cavalier use of setjmp/longjmp. 4328 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) { 4329 collectLocals(); 4330 4331 if (Locals.empty()) return; 4332 4333 // Collect all the blocks in the function. 4334 for (llvm::Function::iterator 4335 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I) 4336 BlocksBeforeTry.insert(&*I); 4337 4338 llvm::FunctionType *AsmFnTy = GetAsmFnType(); 4339 4340 // Create a read hazard for the allocas. This inhibits dead-store 4341 // optimizations and forces the values to memory. This hazard is 4342 // inserted before any 'throwing' calls in the protected scope to 4343 // reflect the possibility that the variables might be read from the 4344 // catch block if the call throws. 4345 { 4346 std::string Constraint; 4347 for (unsigned I = 0, E = Locals.size(); I != E; ++I) { 4348 if (I) Constraint += ','; 4349 Constraint += "*m"; 4350 } 4351 4352 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false); 4353 } 4354 4355 // Create a write hazard for the allocas. This inhibits folding 4356 // loads across the hazard. This hazard is inserted at the 4357 // beginning of the catch path to reflect the possibility that the 4358 // variables might have been written within the protected scope. 4359 { 4360 std::string Constraint; 4361 for (unsigned I = 0, E = Locals.size(); I != E; ++I) { 4362 if (I) Constraint += ','; 4363 Constraint += "=*m"; 4364 } 4365 4366 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false); 4367 } 4368 } 4369 4370 /// Emit a write hazard at the current location. 4371 void FragileHazards::emitWriteHazard() { 4372 if (Locals.empty()) return; 4373 4374 llvm::CallInst *Call = CGF.EmitNounwindRuntimeCall(WriteHazard, Locals); 4375 for (auto Pair : llvm::enumerate(Locals)) 4376 Call->addParamAttr(Pair.index(), llvm::Attribute::get( 4377 CGF.getLLVMContext(), llvm::Attribute::ElementType, 4378 cast<llvm::AllocaInst>(Pair.value())->getAllocatedType())); 4379 } 4380 4381 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) { 4382 assert(!Locals.empty()); 4383 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals); 4384 call->setDoesNotThrow(); 4385 call->setCallingConv(CGF.getRuntimeCC()); 4386 for (auto Pair : llvm::enumerate(Locals)) 4387 call->addParamAttr(Pair.index(), llvm::Attribute::get( 4388 Builder.getContext(), llvm::Attribute::ElementType, 4389 cast<llvm::AllocaInst>(Pair.value())->getAllocatedType())); 4390 } 4391 4392 /// Emit read hazards in all the protected blocks, i.e. all the blocks 4393 /// which have been inserted since the beginning of the try. 4394 void FragileHazards::emitHazardsInNewBlocks() { 4395 if (Locals.empty()) return; 4396 4397 CGBuilderTy Builder(CGF, CGF.getLLVMContext()); 4398 4399 // Iterate through all blocks, skipping those prior to the try. 4400 for (llvm::Function::iterator 4401 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) { 4402 llvm::BasicBlock &BB = *FI; 4403 if (BlocksBeforeTry.count(&BB)) continue; 4404 4405 // Walk through all the calls in the block. 4406 for (llvm::BasicBlock::iterator 4407 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) { 4408 llvm::Instruction &I = *BI; 4409 4410 // Ignore instructions that aren't non-intrinsic calls. 4411 // These are the only calls that can possibly call longjmp. 4412 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) 4413 continue; 4414 if (isa<llvm::IntrinsicInst>(I)) 4415 continue; 4416 4417 // Ignore call sites marked nounwind. This may be questionable, 4418 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'. 4419 if (cast<llvm::CallBase>(I).doesNotThrow()) 4420 continue; 4421 4422 // Insert a read hazard before the call. This will ensure that 4423 // any writes to the locals are performed before making the 4424 // call. If the call throws, then this is sufficient to 4425 // guarantee correctness as long as it doesn't also write to any 4426 // locals. 4427 Builder.SetInsertPoint(&BB, BI); 4428 emitReadHazard(Builder); 4429 } 4430 } 4431 } 4432 4433 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) { 4434 if (V.isValid()) S.insert(V.getPointer()); 4435 } 4436 4437 void FragileHazards::collectLocals() { 4438 // Compute a set of allocas to ignore. 4439 llvm::DenseSet<llvm::Value*> AllocasToIgnore; 4440 addIfPresent(AllocasToIgnore, CGF.ReturnValue); 4441 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest); 4442 4443 // Collect all the allocas currently in the function. This is 4444 // probably way too aggressive. 4445 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock(); 4446 for (llvm::BasicBlock::iterator 4447 I = Entry.begin(), E = Entry.end(); I != E; ++I) 4448 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I)) 4449 Locals.push_back(&*I); 4450 } 4451 4452 llvm::FunctionType *FragileHazards::GetAsmFnType() { 4453 SmallVector<llvm::Type *, 16> tys(Locals.size()); 4454 for (unsigned i = 0, e = Locals.size(); i != e; ++i) 4455 tys[i] = Locals[i]->getType(); 4456 return llvm::FunctionType::get(CGF.VoidTy, tys, false); 4457 } 4458 4459 /* 4460 4461 Objective-C setjmp-longjmp (sjlj) Exception Handling 4462 -- 4463 4464 A catch buffer is a setjmp buffer plus: 4465 - a pointer to the exception that was caught 4466 - a pointer to the previous exception data buffer 4467 - two pointers of reserved storage 4468 Therefore catch buffers form a stack, with a pointer to the top 4469 of the stack kept in thread-local storage. 4470 4471 objc_exception_try_enter pushes a catch buffer onto the EH stack. 4472 objc_exception_try_exit pops the given catch buffer, which is 4473 required to be the top of the EH stack. 4474 objc_exception_throw pops the top of the EH stack, writes the 4475 thrown exception into the appropriate field, and longjmps 4476 to the setjmp buffer. It crashes the process (with a printf 4477 and an abort()) if there are no catch buffers on the stack. 4478 objc_exception_extract just reads the exception pointer out of the 4479 catch buffer. 4480 4481 There's no reason an implementation couldn't use a light-weight 4482 setjmp here --- something like __builtin_setjmp, but API-compatible 4483 with the heavyweight setjmp. This will be more important if we ever 4484 want to implement correct ObjC/C++ exception interactions for the 4485 fragile ABI. 4486 4487 Note that for this use of setjmp/longjmp to be correct, we may need 4488 to mark some local variables volatile: if a non-volatile local 4489 variable is modified between the setjmp and the longjmp, it has 4490 indeterminate value. For the purposes of LLVM IR, it may be 4491 sufficient to make loads and stores within the @try (to variables 4492 declared outside the @try) volatile. This is necessary for 4493 optimized correctness, but is not currently being done; this is 4494 being tracked as rdar://problem/8160285 4495 4496 The basic framework for a @try-catch-finally is as follows: 4497 { 4498 objc_exception_data d; 4499 id _rethrow = null; 4500 bool _call_try_exit = true; 4501 4502 objc_exception_try_enter(&d); 4503 if (!setjmp(d.jmp_buf)) { 4504 ... try body ... 4505 } else { 4506 // exception path 4507 id _caught = objc_exception_extract(&d); 4508 4509 // enter new try scope for handlers 4510 if (!setjmp(d.jmp_buf)) { 4511 ... match exception and execute catch blocks ... 4512 4513 // fell off end, rethrow. 4514 _rethrow = _caught; 4515 ... jump-through-finally to finally_rethrow ... 4516 } else { 4517 // exception in catch block 4518 _rethrow = objc_exception_extract(&d); 4519 _call_try_exit = false; 4520 ... jump-through-finally to finally_rethrow ... 4521 } 4522 } 4523 ... jump-through-finally to finally_end ... 4524 4525 finally: 4526 if (_call_try_exit) 4527 objc_exception_try_exit(&d); 4528 4529 ... finally block .... 4530 ... dispatch to finally destination ... 4531 4532 finally_rethrow: 4533 objc_exception_throw(_rethrow); 4534 4535 finally_end: 4536 } 4537 4538 This framework differs slightly from the one gcc uses, in that gcc 4539 uses _rethrow to determine if objc_exception_try_exit should be called 4540 and if the object should be rethrown. This breaks in the face of 4541 throwing nil and introduces unnecessary branches. 4542 4543 We specialize this framework for a few particular circumstances: 4544 4545 - If there are no catch blocks, then we avoid emitting the second 4546 exception handling context. 4547 4548 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id 4549 e)) we avoid emitting the code to rethrow an uncaught exception. 4550 4551 - FIXME: If there is no @finally block we can do a few more 4552 simplifications. 4553 4554 Rethrows and Jumps-Through-Finally 4555 -- 4556 4557 '@throw;' is supported by pushing the currently-caught exception 4558 onto ObjCEHStack while the @catch blocks are emitted. 4559 4560 Branches through the @finally block are handled with an ordinary 4561 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC 4562 exceptions are not compatible with C++ exceptions, and this is 4563 hardly the only place where this will go wrong. 4564 4565 @synchronized(expr) { stmt; } is emitted as if it were: 4566 id synch_value = expr; 4567 objc_sync_enter(synch_value); 4568 @try { stmt; } @finally { objc_sync_exit(synch_value); } 4569 */ 4570 4571 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 4572 const Stmt &S) { 4573 bool isTry = isa<ObjCAtTryStmt>(S); 4574 4575 // A destination for the fall-through edges of the catch handlers to 4576 // jump to. 4577 CodeGenFunction::JumpDest FinallyEnd = 4578 CGF.getJumpDestInCurrentScope("finally.end"); 4579 4580 // A destination for the rethrow edge of the catch handlers to jump 4581 // to. 4582 CodeGenFunction::JumpDest FinallyRethrow = 4583 CGF.getJumpDestInCurrentScope("finally.rethrow"); 4584 4585 // For @synchronized, call objc_sync_enter(sync.expr). The 4586 // evaluation of the expression must occur before we enter the 4587 // @synchronized. We can't avoid a temp here because we need the 4588 // value to be preserved. If the backend ever does liveness 4589 // correctly after setjmp, this will be unnecessary. 4590 Address SyncArgSlot = Address::invalid(); 4591 if (!isTry) { 4592 llvm::Value *SyncArg = 4593 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr()); 4594 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy); 4595 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg); 4596 4597 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(), 4598 CGF.getPointerAlign(), "sync.arg"); 4599 CGF.Builder.CreateStore(SyncArg, SyncArgSlot); 4600 } 4601 4602 // Allocate memory for the setjmp buffer. This needs to be kept 4603 // live throughout the try and catch blocks. 4604 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy, 4605 CGF.getPointerAlign(), 4606 "exceptiondata.ptr"); 4607 4608 // Create the fragile hazards. Note that this will not capture any 4609 // of the allocas required for exception processing, but will 4610 // capture the current basic block (which extends all the way to the 4611 // setjmp call) as "before the @try". 4612 FragileHazards Hazards(CGF); 4613 4614 // Create a flag indicating whether the cleanup needs to call 4615 // objc_exception_try_exit. This is true except when 4616 // - no catches match and we're branching through the cleanup 4617 // just to rethrow the exception, or 4618 // - a catch matched and we're falling out of the catch handler. 4619 // The setjmp-safety rule here is that we should always store to this 4620 // variable in a place that dominates the branch through the cleanup 4621 // without passing through any setjmps. 4622 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), 4623 CharUnits::One(), 4624 "_call_try_exit"); 4625 4626 // A slot containing the exception to rethrow. Only needed when we 4627 // have both a @catch and a @finally. 4628 Address PropagatingExnVar = Address::invalid(); 4629 4630 // Push a normal cleanup to leave the try scope. 4631 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S, 4632 SyncArgSlot, 4633 CallTryExitVar, 4634 ExceptionData, 4635 &ObjCTypes); 4636 4637 // Enter a try block: 4638 // - Call objc_exception_try_enter to push ExceptionData on top of 4639 // the EH stack. 4640 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(), 4641 ExceptionData.getPointer()); 4642 4643 // - Call setjmp on the exception data buffer. 4644 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0); 4645 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero }; 4646 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP( 4647 ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes, 4648 "setjmp_buffer"); 4649 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall( 4650 ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result"); 4651 SetJmpResult->setCanReturnTwice(); 4652 4653 // If setjmp returned 0, enter the protected block; otherwise, 4654 // branch to the handler. 4655 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try"); 4656 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler"); 4657 llvm::Value *DidCatch = 4658 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception"); 4659 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock); 4660 4661 // Emit the protected block. 4662 CGF.EmitBlock(TryBlock); 4663 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar); 4664 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody() 4665 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody()); 4666 4667 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP(); 4668 4669 // Emit the exception handler block. 4670 CGF.EmitBlock(TryHandler); 4671 4672 // Don't optimize loads of the in-scope locals across this point. 4673 Hazards.emitWriteHazard(); 4674 4675 // For a @synchronized (or a @try with no catches), just branch 4676 // through the cleanup to the rethrow block. 4677 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) { 4678 // Tell the cleanup not to re-pop the exit. 4679 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar); 4680 CGF.EmitBranchThroughCleanup(FinallyRethrow); 4681 4682 // Otherwise, we have to match against the caught exceptions. 4683 } else { 4684 // Retrieve the exception object. We may emit multiple blocks but 4685 // nothing can cross this so the value is already in SSA form. 4686 llvm::CallInst *Caught = 4687 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(), 4688 ExceptionData.getPointer(), "caught"); 4689 4690 // Push the exception to rethrow onto the EH value stack for the 4691 // benefit of any @throws in the handlers. 4692 CGF.ObjCEHValueStack.push_back(Caught); 4693 4694 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S); 4695 4696 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr); 4697 4698 llvm::BasicBlock *CatchBlock = nullptr; 4699 llvm::BasicBlock *CatchHandler = nullptr; 4700 if (HasFinally) { 4701 // Save the currently-propagating exception before 4702 // objc_exception_try_enter clears the exception slot. 4703 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(), 4704 CGF.getPointerAlign(), 4705 "propagating_exception"); 4706 CGF.Builder.CreateStore(Caught, PropagatingExnVar); 4707 4708 // Enter a new exception try block (in case a @catch block 4709 // throws an exception). 4710 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(), 4711 ExceptionData.getPointer()); 4712 4713 llvm::CallInst *SetJmpResult = 4714 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(), 4715 SetJmpBuffer, "setjmp.result"); 4716 SetJmpResult->setCanReturnTwice(); 4717 4718 llvm::Value *Threw = 4719 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception"); 4720 4721 CatchBlock = CGF.createBasicBlock("catch"); 4722 CatchHandler = CGF.createBasicBlock("catch_for_catch"); 4723 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock); 4724 4725 CGF.EmitBlock(CatchBlock); 4726 } 4727 4728 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar); 4729 4730 // Handle catch list. As a special case we check if everything is 4731 // matched and avoid generating code for falling off the end if 4732 // so. 4733 bool AllMatched = false; 4734 for (const ObjCAtCatchStmt *CatchStmt : AtTryStmt->catch_stmts()) { 4735 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl(); 4736 const ObjCObjectPointerType *OPT = nullptr; 4737 4738 // catch(...) always matches. 4739 if (!CatchParam) { 4740 AllMatched = true; 4741 } else { 4742 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>(); 4743 4744 // catch(id e) always matches under this ABI, since only 4745 // ObjC exceptions end up here in the first place. 4746 // FIXME: For the time being we also match id<X>; this should 4747 // be rejected by Sema instead. 4748 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType())) 4749 AllMatched = true; 4750 } 4751 4752 // If this is a catch-all, we don't need to test anything. 4753 if (AllMatched) { 4754 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF); 4755 4756 if (CatchParam) { 4757 CGF.EmitAutoVarDecl(*CatchParam); 4758 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); 4759 4760 // These types work out because ConvertType(id) == i8*. 4761 EmitInitOfCatchParam(CGF, Caught, CatchParam); 4762 } 4763 4764 CGF.EmitStmt(CatchStmt->getCatchBody()); 4765 4766 // The scope of the catch variable ends right here. 4767 CatchVarCleanups.ForceCleanup(); 4768 4769 CGF.EmitBranchThroughCleanup(FinallyEnd); 4770 break; 4771 } 4772 4773 assert(OPT && "Unexpected non-object pointer type in @catch"); 4774 const ObjCObjectType *ObjTy = OPT->getObjectType(); 4775 4776 // FIXME: @catch (Class c) ? 4777 ObjCInterfaceDecl *IDecl = ObjTy->getInterface(); 4778 assert(IDecl && "Catch parameter must have Objective-C type!"); 4779 4780 // Check if the @catch block matches the exception object. 4781 llvm::Value *Class = EmitClassRef(CGF, IDecl); 4782 4783 llvm::Value *matchArgs[] = { Class, Caught }; 4784 llvm::CallInst *Match = 4785 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(), 4786 matchArgs, "match"); 4787 4788 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match"); 4789 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next"); 4790 4791 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"), 4792 MatchedBlock, NextCatchBlock); 4793 4794 // Emit the @catch block. 4795 CGF.EmitBlock(MatchedBlock); 4796 4797 // Collect any cleanups for the catch variable. The scope lasts until 4798 // the end of the catch body. 4799 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF); 4800 4801 CGF.EmitAutoVarDecl(*CatchParam); 4802 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); 4803 4804 // Initialize the catch variable. 4805 llvm::Value *Tmp = 4806 CGF.Builder.CreateBitCast(Caught, 4807 CGF.ConvertType(CatchParam->getType())); 4808 EmitInitOfCatchParam(CGF, Tmp, CatchParam); 4809 4810 CGF.EmitStmt(CatchStmt->getCatchBody()); 4811 4812 // We're done with the catch variable. 4813 CatchVarCleanups.ForceCleanup(); 4814 4815 CGF.EmitBranchThroughCleanup(FinallyEnd); 4816 4817 CGF.EmitBlock(NextCatchBlock); 4818 } 4819 4820 CGF.ObjCEHValueStack.pop_back(); 4821 4822 // If nothing wanted anything to do with the caught exception, 4823 // kill the extract call. 4824 if (Caught->use_empty()) 4825 Caught->eraseFromParent(); 4826 4827 if (!AllMatched) 4828 CGF.EmitBranchThroughCleanup(FinallyRethrow); 4829 4830 if (HasFinally) { 4831 // Emit the exception handler for the @catch blocks. 4832 CGF.EmitBlock(CatchHandler); 4833 4834 // In theory we might now need a write hazard, but actually it's 4835 // unnecessary because there's no local-accessing code between 4836 // the try's write hazard and here. 4837 //Hazards.emitWriteHazard(); 4838 4839 // Extract the new exception and save it to the 4840 // propagating-exception slot. 4841 assert(PropagatingExnVar.isValid()); 4842 llvm::CallInst *NewCaught = 4843 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(), 4844 ExceptionData.getPointer(), "caught"); 4845 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar); 4846 4847 // Don't pop the catch handler; the throw already did. 4848 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar); 4849 CGF.EmitBranchThroughCleanup(FinallyRethrow); 4850 } 4851 } 4852 4853 // Insert read hazards as required in the new blocks. 4854 Hazards.emitHazardsInNewBlocks(); 4855 4856 // Pop the cleanup. 4857 CGF.Builder.restoreIP(TryFallthroughIP); 4858 if (CGF.HaveInsertPoint()) 4859 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar); 4860 CGF.PopCleanupBlock(); 4861 CGF.EmitBlock(FinallyEnd.getBlock(), true); 4862 4863 // Emit the rethrow block. 4864 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); 4865 CGF.EmitBlock(FinallyRethrow.getBlock(), true); 4866 if (CGF.HaveInsertPoint()) { 4867 // If we have a propagating-exception variable, check it. 4868 llvm::Value *PropagatingExn; 4869 if (PropagatingExnVar.isValid()) { 4870 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar); 4871 4872 // Otherwise, just look in the buffer for the exception to throw. 4873 } else { 4874 llvm::CallInst *Caught = 4875 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(), 4876 ExceptionData.getPointer()); 4877 PropagatingExn = Caught; 4878 } 4879 4880 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(), 4881 PropagatingExn); 4882 CGF.Builder.CreateUnreachable(); 4883 } 4884 4885 CGF.Builder.restoreIP(SavedIP); 4886 } 4887 4888 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 4889 const ObjCAtThrowStmt &S, 4890 bool ClearInsertionPoint) { 4891 llvm::Value *ExceptionAsObject; 4892 4893 if (const Expr *ThrowExpr = S.getThrowExpr()) { 4894 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr); 4895 ExceptionAsObject = 4896 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy); 4897 } else { 4898 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && 4899 "Unexpected rethrow outside @catch block."); 4900 ExceptionAsObject = CGF.ObjCEHValueStack.back(); 4901 } 4902 4903 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject) 4904 ->setDoesNotReturn(); 4905 CGF.Builder.CreateUnreachable(); 4906 4907 // Clear the insertion point to indicate we are in unreachable code. 4908 if (ClearInsertionPoint) 4909 CGF.Builder.ClearInsertionPoint(); 4910 } 4911 4912 /// EmitObjCWeakRead - Code gen for loading value of a __weak 4913 /// object: objc_read_weak (id *src) 4914 /// 4915 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 4916 Address AddrWeakObj) { 4917 llvm::Type* DestTy = AddrWeakObj.getElementType(); 4918 llvm::Value *AddrWeakObjVal = CGF.Builder.CreateBitCast( 4919 AddrWeakObj.getPointer(), ObjCTypes.PtrObjectPtrTy); 4920 llvm::Value *read_weak = 4921 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(), 4922 AddrWeakObjVal, "weakread"); 4923 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); 4924 return read_weak; 4925 } 4926 4927 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object. 4928 /// objc_assign_weak (id src, id *dst) 4929 /// 4930 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 4931 llvm::Value *src, Address dst) { 4932 llvm::Type * SrcTy = src->getType(); 4933 if (!isa<llvm::PointerType>(SrcTy)) { 4934 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); 4935 assert(Size <= 8 && "does not support size > 8"); 4936 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) 4937 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); 4938 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 4939 } 4940 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 4941 llvm::Value *dstVal = 4942 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy); 4943 llvm::Value *args[] = { src, dstVal }; 4944 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(), 4945 args, "weakassign"); 4946 } 4947 4948 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object. 4949 /// objc_assign_global (id src, id *dst) 4950 /// 4951 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 4952 llvm::Value *src, Address dst, 4953 bool threadlocal) { 4954 llvm::Type * SrcTy = src->getType(); 4955 if (!isa<llvm::PointerType>(SrcTy)) { 4956 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); 4957 assert(Size <= 8 && "does not support size > 8"); 4958 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) 4959 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); 4960 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 4961 } 4962 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 4963 llvm::Value *dstVal = 4964 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy); 4965 llvm::Value *args[] = {src, dstVal}; 4966 if (!threadlocal) 4967 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(), 4968 args, "globalassign"); 4969 else 4970 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(), 4971 args, "threadlocalassign"); 4972 } 4973 4974 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object. 4975 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset) 4976 /// 4977 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 4978 llvm::Value *src, Address dst, 4979 llvm::Value *ivarOffset) { 4980 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL"); 4981 llvm::Type * SrcTy = src->getType(); 4982 if (!isa<llvm::PointerType>(SrcTy)) { 4983 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); 4984 assert(Size <= 8 && "does not support size > 8"); 4985 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) 4986 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); 4987 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 4988 } 4989 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 4990 llvm::Value *dstVal = 4991 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy); 4992 llvm::Value *args[] = {src, dstVal, ivarOffset}; 4993 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args); 4994 } 4995 4996 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object. 4997 /// objc_assign_strongCast (id src, id *dst) 4998 /// 4999 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 5000 llvm::Value *src, Address dst) { 5001 llvm::Type * SrcTy = src->getType(); 5002 if (!isa<llvm::PointerType>(SrcTy)) { 5003 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); 5004 assert(Size <= 8 && "does not support size > 8"); 5005 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) 5006 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); 5007 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5008 } 5009 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5010 llvm::Value *dstVal = 5011 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy); 5012 llvm::Value *args[] = {src, dstVal}; 5013 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(), 5014 args, "strongassign"); 5015 } 5016 5017 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, 5018 Address DestPtr, 5019 Address SrcPtr, 5020 llvm::Value *size) { 5021 SrcPtr = CGF.Builder.CreateElementBitCast(SrcPtr, CGF.Int8Ty); 5022 DestPtr = CGF.Builder.CreateElementBitCast(DestPtr, CGF.Int8Ty); 5023 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size }; 5024 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args); 5025 } 5026 5027 /// EmitObjCValueForIvar - Code Gen for ivar reference. 5028 /// 5029 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, 5030 QualType ObjectTy, 5031 llvm::Value *BaseValue, 5032 const ObjCIvarDecl *Ivar, 5033 unsigned CVRQualifiers) { 5034 const ObjCInterfaceDecl *ID = 5035 ObjectTy->castAs<ObjCObjectType>()->getInterface(); 5036 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, 5037 EmitIvarOffset(CGF, ID, Ivar)); 5038 } 5039 5040 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 5041 const ObjCInterfaceDecl *Interface, 5042 const ObjCIvarDecl *Ivar) { 5043 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar); 5044 return llvm::ConstantInt::get( 5045 CGM.getTypes().ConvertType(CGM.getContext().LongTy), 5046 Offset); 5047 } 5048 5049 /* *** Private Interface *** */ 5050 5051 std::string CGObjCCommonMac::GetSectionName(StringRef Section, 5052 StringRef MachOAttributes) { 5053 switch (CGM.getTriple().getObjectFormat()) { 5054 case llvm::Triple::UnknownObjectFormat: 5055 llvm_unreachable("unexpected object file format"); 5056 case llvm::Triple::MachO: { 5057 if (MachOAttributes.empty()) 5058 return ("__DATA," + Section).str(); 5059 return ("__DATA," + Section + "," + MachOAttributes).str(); 5060 } 5061 case llvm::Triple::ELF: 5062 assert(Section.substr(0, 2) == "__" && 5063 "expected the name to begin with __"); 5064 return Section.substr(2).str(); 5065 case llvm::Triple::COFF: 5066 assert(Section.substr(0, 2) == "__" && 5067 "expected the name to begin with __"); 5068 return ("." + Section.substr(2) + "$B").str(); 5069 case llvm::Triple::Wasm: 5070 case llvm::Triple::GOFF: 5071 case llvm::Triple::SPIRV: 5072 case llvm::Triple::XCOFF: 5073 case llvm::Triple::DXContainer: 5074 llvm::report_fatal_error( 5075 "Objective-C support is unimplemented for object file format"); 5076 } 5077 5078 llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum"); 5079 } 5080 5081 /// EmitImageInfo - Emit the image info marker used to encode some module 5082 /// level information. 5083 /// 5084 /// See: <rdr://4810609&4810587&4810587> 5085 /// struct IMAGE_INFO { 5086 /// unsigned version; 5087 /// unsigned flags; 5088 /// }; 5089 enum ImageInfoFlags { 5090 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang. 5091 eImageInfo_GarbageCollected = (1 << 1), 5092 eImageInfo_GCOnly = (1 << 2), 5093 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache. 5094 5095 // A flag indicating that the module has no instances of a @synthesize of a 5096 // superclass variable. <rdar://problem/6803242> 5097 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang. 5098 eImageInfo_ImageIsSimulated = (1 << 5), 5099 eImageInfo_ClassProperties = (1 << 6) 5100 }; 5101 5102 void CGObjCCommonMac::EmitImageInfo() { 5103 unsigned version = 0; // Version is unused? 5104 std::string Section = 5105 (ObjCABI == 1) 5106 ? "__OBJC,__image_info,regular" 5107 : GetSectionName("__objc_imageinfo", "regular,no_dead_strip"); 5108 5109 // Generate module-level named metadata to convey this information to the 5110 // linker and code-gen. 5111 llvm::Module &Mod = CGM.getModule(); 5112 5113 // Add the ObjC ABI version to the module flags. 5114 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI); 5115 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version", 5116 version); 5117 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section", 5118 llvm::MDString::get(VMContext, Section)); 5119 5120 auto Int8Ty = llvm::Type::getInt8Ty(VMContext); 5121 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { 5122 // Non-GC overrides those files which specify GC. 5123 Mod.addModuleFlag(llvm::Module::Error, 5124 "Objective-C Garbage Collection", 5125 llvm::ConstantInt::get(Int8Ty,0)); 5126 } else { 5127 // Add the ObjC garbage collection value. 5128 Mod.addModuleFlag(llvm::Module::Error, 5129 "Objective-C Garbage Collection", 5130 llvm::ConstantInt::get(Int8Ty, 5131 (uint8_t)eImageInfo_GarbageCollected)); 5132 5133 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) { 5134 // Add the ObjC GC Only value. 5135 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only", 5136 eImageInfo_GCOnly); 5137 5138 // Require that GC be specified and set to eImageInfo_GarbageCollected. 5139 llvm::Metadata *Ops[2] = { 5140 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"), 5141 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( 5142 Int8Ty, eImageInfo_GarbageCollected))}; 5143 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only", 5144 llvm::MDNode::get(VMContext, Ops)); 5145 } 5146 } 5147 5148 // Indicate whether we're compiling this to run on a simulator. 5149 if (CGM.getTarget().getTriple().isSimulatorEnvironment()) 5150 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated", 5151 eImageInfo_ImageIsSimulated); 5152 5153 // Indicate whether we are generating class properties. 5154 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties", 5155 eImageInfo_ClassProperties); 5156 } 5157 5158 // struct objc_module { 5159 // unsigned long version; 5160 // unsigned long size; 5161 // const char *name; 5162 // Symtab symtab; 5163 // }; 5164 5165 // FIXME: Get from somewhere 5166 static const int ModuleVersion = 7; 5167 5168 void CGObjCMac::EmitModuleInfo() { 5169 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy); 5170 5171 ConstantInitBuilder builder(CGM); 5172 auto values = builder.beginStruct(ObjCTypes.ModuleTy); 5173 values.addInt(ObjCTypes.LongTy, ModuleVersion); 5174 values.addInt(ObjCTypes.LongTy, Size); 5175 // This used to be the filename, now it is unused. <rdr://4327263> 5176 values.add(GetClassName(StringRef(""))); 5177 values.add(EmitModuleSymbols()); 5178 CreateMetadataVar("OBJC_MODULES", values, 5179 "__OBJC,__module_info,regular,no_dead_strip", 5180 CGM.getPointerAlign(), true); 5181 } 5182 5183 llvm::Constant *CGObjCMac::EmitModuleSymbols() { 5184 unsigned NumClasses = DefinedClasses.size(); 5185 unsigned NumCategories = DefinedCategories.size(); 5186 5187 // Return null if no symbols were defined. 5188 if (!NumClasses && !NumCategories) 5189 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy); 5190 5191 ConstantInitBuilder builder(CGM); 5192 auto values = builder.beginStruct(); 5193 values.addInt(ObjCTypes.LongTy, 0); 5194 values.addNullPointer(ObjCTypes.SelectorPtrTy); 5195 values.addInt(ObjCTypes.ShortTy, NumClasses); 5196 values.addInt(ObjCTypes.ShortTy, NumCategories); 5197 5198 // The runtime expects exactly the list of defined classes followed 5199 // by the list of defined categories, in a single array. 5200 auto array = values.beginArray(ObjCTypes.Int8PtrTy); 5201 for (unsigned i=0; i<NumClasses; i++) { 5202 const ObjCInterfaceDecl *ID = ImplementedClasses[i]; 5203 assert(ID); 5204 if (ObjCImplementationDecl *IMP = ID->getImplementation()) 5205 // We are implementing a weak imported interface. Give it external linkage 5206 if (ID->isWeakImported() && !IMP->isWeakImported()) 5207 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage); 5208 5209 array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy); 5210 } 5211 for (unsigned i=0; i<NumCategories; i++) 5212 array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy); 5213 5214 array.finishAndAddTo(values); 5215 5216 llvm::GlobalVariable *GV = CreateMetadataVar( 5217 "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip", 5218 CGM.getPointerAlign(), true); 5219 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy); 5220 } 5221 5222 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF, 5223 IdentifierInfo *II) { 5224 LazySymbols.insert(II); 5225 5226 llvm::GlobalVariable *&Entry = ClassReferences[II]; 5227 5228 if (!Entry) { 5229 llvm::Constant *Casted = 5230 llvm::ConstantExpr::getBitCast(GetClassName(II->getName()), 5231 ObjCTypes.ClassPtrTy); 5232 Entry = CreateMetadataVar( 5233 "OBJC_CLASS_REFERENCES_", Casted, 5234 "__OBJC,__cls_refs,literal_pointers,no_dead_strip", 5235 CGM.getPointerAlign(), true); 5236 } 5237 5238 return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry, 5239 CGF.getPointerAlign()); 5240 } 5241 5242 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF, 5243 const ObjCInterfaceDecl *ID) { 5244 // If the class has the objc_runtime_visible attribute, we need to 5245 // use the Objective-C runtime to get the class. 5246 if (ID->hasAttr<ObjCRuntimeVisibleAttr>()) 5247 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes); 5248 5249 IdentifierInfo *RuntimeName = 5250 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString()); 5251 return EmitClassRefFromId(CGF, RuntimeName); 5252 } 5253 5254 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) { 5255 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool"); 5256 return EmitClassRefFromId(CGF, II); 5257 } 5258 5259 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) { 5260 return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel)); 5261 } 5262 5263 Address CGObjCMac::EmitSelectorAddr(Selector Sel) { 5264 CharUnits Align = CGM.getPointerAlign(); 5265 5266 llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; 5267 if (!Entry) { 5268 llvm::Constant *Casted = 5269 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel), 5270 ObjCTypes.SelectorPtrTy); 5271 Entry = CreateMetadataVar( 5272 "OBJC_SELECTOR_REFERENCES_", Casted, 5273 "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true); 5274 Entry->setExternallyInitialized(true); 5275 } 5276 5277 return Address(Entry, ObjCTypes.SelectorPtrTy, Align); 5278 } 5279 5280 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) { 5281 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName]; 5282 if (!Entry) 5283 Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName); 5284 return getConstantGEP(VMContext, Entry, 0, 0); 5285 } 5286 5287 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) { 5288 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator 5289 I = MethodDefinitions.find(MD); 5290 if (I != MethodDefinitions.end()) 5291 return I->second; 5292 5293 return nullptr; 5294 } 5295 5296 /// GetIvarLayoutName - Returns a unique constant for the given 5297 /// ivar layout bitmap. 5298 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident, 5299 const ObjCCommonTypesHelper &ObjCTypes) { 5300 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 5301 } 5302 5303 void IvarLayoutBuilder::visitRecord(const RecordType *RT, 5304 CharUnits offset) { 5305 const RecordDecl *RD = RT->getDecl(); 5306 5307 // If this is a union, remember that we had one, because it might mess 5308 // up the ordering of layout entries. 5309 if (RD->isUnion()) 5310 IsDisordered = true; 5311 5312 const ASTRecordLayout *recLayout = nullptr; 5313 visitAggregate(RD->field_begin(), RD->field_end(), offset, 5314 [&](const FieldDecl *field) -> CharUnits { 5315 if (!recLayout) 5316 recLayout = &CGM.getContext().getASTRecordLayout(RD); 5317 auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex()); 5318 return CGM.getContext().toCharUnitsFromBits(offsetInBits); 5319 }); 5320 } 5321 5322 template <class Iterator, class GetOffsetFn> 5323 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end, 5324 CharUnits aggregateOffset, 5325 const GetOffsetFn &getOffset) { 5326 for (; begin != end; ++begin) { 5327 auto field = *begin; 5328 5329 // Skip over bitfields. 5330 if (field->isBitField()) { 5331 continue; 5332 } 5333 5334 // Compute the offset of the field within the aggregate. 5335 CharUnits fieldOffset = aggregateOffset + getOffset(field); 5336 5337 visitField(field, fieldOffset); 5338 } 5339 } 5340 5341 /// Collect layout information for the given fields into IvarsInfo. 5342 void IvarLayoutBuilder::visitField(const FieldDecl *field, 5343 CharUnits fieldOffset) { 5344 QualType fieldType = field->getType(); 5345 5346 // Drill down into arrays. 5347 uint64_t numElts = 1; 5348 if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) { 5349 numElts = 0; 5350 fieldType = arrayType->getElementType(); 5351 } 5352 // Unlike incomplete arrays, constant arrays can be nested. 5353 while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) { 5354 numElts *= arrayType->getSize().getZExtValue(); 5355 fieldType = arrayType->getElementType(); 5356 } 5357 5358 assert(!fieldType->isArrayType() && "ivar of non-constant array type?"); 5359 5360 // If we ended up with a zero-sized array, we've done what we can do within 5361 // the limits of this layout encoding. 5362 if (numElts == 0) return; 5363 5364 // Recurse if the base element type is a record type. 5365 if (auto recType = fieldType->getAs<RecordType>()) { 5366 size_t oldEnd = IvarsInfo.size(); 5367 5368 visitRecord(recType, fieldOffset); 5369 5370 // If we have an array, replicate the first entry's layout information. 5371 auto numEltEntries = IvarsInfo.size() - oldEnd; 5372 if (numElts != 1 && numEltEntries != 0) { 5373 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType); 5374 for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) { 5375 // Copy the last numEltEntries onto the end of the array, adjusting 5376 // each for the element size. 5377 for (size_t i = 0; i != numEltEntries; ++i) { 5378 auto firstEntry = IvarsInfo[oldEnd + i]; 5379 IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize, 5380 firstEntry.SizeInWords)); 5381 } 5382 } 5383 } 5384 5385 return; 5386 } 5387 5388 // Classify the element type. 5389 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType); 5390 5391 // If it matches what we're looking for, add an entry. 5392 if ((ForStrongLayout && GCAttr == Qualifiers::Strong) 5393 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) { 5394 assert(CGM.getContext().getTypeSizeInChars(fieldType) 5395 == CGM.getPointerSize()); 5396 IvarsInfo.push_back(IvarInfo(fieldOffset, numElts)); 5397 } 5398 } 5399 5400 /// buildBitmap - This routine does the horsework of taking the offsets of 5401 /// strong/weak references and creating a bitmap. The bitmap is also 5402 /// returned in the given buffer, suitable for being passed to \c dump(). 5403 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC, 5404 llvm::SmallVectorImpl<unsigned char> &buffer) { 5405 // The bitmap is a series of skip/scan instructions, aligned to word 5406 // boundaries. The skip is performed first. 5407 const unsigned char MaxNibble = 0xF; 5408 const unsigned char SkipMask = 0xF0, SkipShift = 4; 5409 const unsigned char ScanMask = 0x0F, ScanShift = 0; 5410 5411 assert(!IvarsInfo.empty() && "generating bitmap for no data"); 5412 5413 // Sort the ivar info on byte position in case we encounterred a 5414 // union nested in the ivar list. 5415 if (IsDisordered) { 5416 // This isn't a stable sort, but our algorithm should handle it fine. 5417 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end()); 5418 } else { 5419 assert(llvm::is_sorted(IvarsInfo)); 5420 } 5421 assert(IvarsInfo.back().Offset < InstanceEnd); 5422 5423 assert(buffer.empty()); 5424 5425 // Skip the next N words. 5426 auto skip = [&](unsigned numWords) { 5427 assert(numWords > 0); 5428 5429 // Try to merge into the previous byte. Since scans happen second, we 5430 // can't do this if it includes a scan. 5431 if (!buffer.empty() && !(buffer.back() & ScanMask)) { 5432 unsigned lastSkip = buffer.back() >> SkipShift; 5433 if (lastSkip < MaxNibble) { 5434 unsigned claimed = std::min(MaxNibble - lastSkip, numWords); 5435 numWords -= claimed; 5436 lastSkip += claimed; 5437 buffer.back() = (lastSkip << SkipShift); 5438 } 5439 } 5440 5441 while (numWords >= MaxNibble) { 5442 buffer.push_back(MaxNibble << SkipShift); 5443 numWords -= MaxNibble; 5444 } 5445 if (numWords) { 5446 buffer.push_back(numWords << SkipShift); 5447 } 5448 }; 5449 5450 // Scan the next N words. 5451 auto scan = [&](unsigned numWords) { 5452 assert(numWords > 0); 5453 5454 // Try to merge into the previous byte. Since scans happen second, we can 5455 // do this even if it includes a skip. 5456 if (!buffer.empty()) { 5457 unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift; 5458 if (lastScan < MaxNibble) { 5459 unsigned claimed = std::min(MaxNibble - lastScan, numWords); 5460 numWords -= claimed; 5461 lastScan += claimed; 5462 buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift); 5463 } 5464 } 5465 5466 while (numWords >= MaxNibble) { 5467 buffer.push_back(MaxNibble << ScanShift); 5468 numWords -= MaxNibble; 5469 } 5470 if (numWords) { 5471 buffer.push_back(numWords << ScanShift); 5472 } 5473 }; 5474 5475 // One past the end of the last scan. 5476 unsigned endOfLastScanInWords = 0; 5477 const CharUnits WordSize = CGM.getPointerSize(); 5478 5479 // Consider all the scan requests. 5480 for (auto &request : IvarsInfo) { 5481 CharUnits beginOfScan = request.Offset - InstanceBegin; 5482 5483 // Ignore scan requests that don't start at an even multiple of the 5484 // word size. We can't encode them. 5485 if ((beginOfScan % WordSize) != 0) continue; 5486 5487 // Ignore scan requests that start before the instance start. 5488 // This assumes that scans never span that boundary. The boundary 5489 // isn't the true start of the ivars, because in the fragile-ARC case 5490 // it's rounded up to word alignment, but the test above should leave 5491 // us ignoring that possibility. 5492 if (beginOfScan.isNegative()) { 5493 assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin); 5494 continue; 5495 } 5496 5497 unsigned beginOfScanInWords = beginOfScan / WordSize; 5498 unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords; 5499 5500 // If the scan starts some number of words after the last one ended, 5501 // skip forward. 5502 if (beginOfScanInWords > endOfLastScanInWords) { 5503 skip(beginOfScanInWords - endOfLastScanInWords); 5504 5505 // Otherwise, start scanning where the last left off. 5506 } else { 5507 beginOfScanInWords = endOfLastScanInWords; 5508 5509 // If that leaves us with nothing to scan, ignore this request. 5510 if (beginOfScanInWords >= endOfScanInWords) continue; 5511 } 5512 5513 // Scan to the end of the request. 5514 assert(beginOfScanInWords < endOfScanInWords); 5515 scan(endOfScanInWords - beginOfScanInWords); 5516 endOfLastScanInWords = endOfScanInWords; 5517 } 5518 5519 if (buffer.empty()) 5520 return llvm::ConstantPointerNull::get(CGM.Int8PtrTy); 5521 5522 // For GC layouts, emit a skip to the end of the allocation so that we 5523 // have precise information about the entire thing. This isn't useful 5524 // or necessary for the ARC-style layout strings. 5525 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) { 5526 unsigned lastOffsetInWords = 5527 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize; 5528 if (lastOffsetInWords > endOfLastScanInWords) { 5529 skip(lastOffsetInWords - endOfLastScanInWords); 5530 } 5531 } 5532 5533 // Null terminate the string. 5534 buffer.push_back(0); 5535 5536 auto *Entry = CGObjC.CreateCStringLiteral( 5537 reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName); 5538 return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0); 5539 } 5540 5541 /// BuildIvarLayout - Builds ivar layout bitmap for the class 5542 /// implementation for the __strong or __weak case. 5543 /// The layout map displays which words in ivar list must be skipped 5544 /// and which must be scanned by GC (see below). String is built of bytes. 5545 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count 5546 /// of words to skip and right nibble is count of words to scan. So, each 5547 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is 5548 /// represented by a 0x00 byte which also ends the string. 5549 /// 1. when ForStrongLayout is true, following ivars are scanned: 5550 /// - id, Class 5551 /// - object * 5552 /// - __strong anything 5553 /// 5554 /// 2. When ForStrongLayout is false, following ivars are scanned: 5555 /// - __weak anything 5556 /// 5557 llvm::Constant * 5558 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD, 5559 CharUnits beginOffset, CharUnits endOffset, 5560 bool ForStrongLayout, bool HasMRCWeakIvars) { 5561 // If this is MRC, and we're either building a strong layout or there 5562 // are no weak ivars, bail out early. 5563 llvm::Type *PtrTy = CGM.Int8PtrTy; 5564 if (CGM.getLangOpts().getGC() == LangOptions::NonGC && 5565 !CGM.getLangOpts().ObjCAutoRefCount && 5566 (ForStrongLayout || !HasMRCWeakIvars)) 5567 return llvm::Constant::getNullValue(PtrTy); 5568 5569 const ObjCInterfaceDecl *OI = OMD->getClassInterface(); 5570 SmallVector<const ObjCIvarDecl*, 32> ivars; 5571 5572 // GC layout strings include the complete object layout, possibly 5573 // inaccurately in the non-fragile ABI; the runtime knows how to fix this 5574 // up. 5575 // 5576 // ARC layout strings only include the class's ivars. In non-fragile 5577 // runtimes, that means starting at InstanceStart, rounded up to word 5578 // alignment. In fragile runtimes, there's no InstanceStart, so it means 5579 // starting at the offset of the first ivar, rounded up to word alignment. 5580 // 5581 // MRC weak layout strings follow the ARC style. 5582 CharUnits baseOffset; 5583 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { 5584 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin(); 5585 IVD; IVD = IVD->getNextIvar()) 5586 ivars.push_back(IVD); 5587 5588 if (isNonFragileABI()) { 5589 baseOffset = beginOffset; // InstanceStart 5590 } else if (!ivars.empty()) { 5591 baseOffset = 5592 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0])); 5593 } else { 5594 baseOffset = CharUnits::Zero(); 5595 } 5596 5597 baseOffset = baseOffset.alignTo(CGM.getPointerAlign()); 5598 } 5599 else { 5600 CGM.getContext().DeepCollectObjCIvars(OI, true, ivars); 5601 5602 baseOffset = CharUnits::Zero(); 5603 } 5604 5605 if (ivars.empty()) 5606 return llvm::Constant::getNullValue(PtrTy); 5607 5608 IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout); 5609 5610 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(), 5611 [&](const ObjCIvarDecl *ivar) -> CharUnits { 5612 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar)); 5613 }); 5614 5615 if (!builder.hasBitmapData()) 5616 return llvm::Constant::getNullValue(PtrTy); 5617 5618 llvm::SmallVector<unsigned char, 4> buffer; 5619 llvm::Constant *C = builder.buildBitmap(*this, buffer); 5620 5621 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) { 5622 printf("\n%s ivar layout for class '%s': ", 5623 ForStrongLayout ? "strong" : "weak", 5624 OMD->getClassInterface()->getName().str().c_str()); 5625 builder.dump(buffer); 5626 } 5627 return C; 5628 } 5629 5630 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) { 5631 llvm::GlobalVariable *&Entry = MethodVarNames[Sel]; 5632 // FIXME: Avoid std::string in "Sel.getAsString()" 5633 if (!Entry) 5634 Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName); 5635 return getConstantGEP(VMContext, Entry, 0, 0); 5636 } 5637 5638 // FIXME: Merge into a single cstring creation function. 5639 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) { 5640 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID)); 5641 } 5642 5643 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) { 5644 std::string TypeStr; 5645 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field); 5646 5647 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; 5648 if (!Entry) 5649 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType); 5650 return getConstantGEP(VMContext, Entry, 0, 0); 5651 } 5652 5653 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D, 5654 bool Extended) { 5655 std::string TypeStr = 5656 CGM.getContext().getObjCEncodingForMethodDecl(D, Extended); 5657 5658 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; 5659 if (!Entry) 5660 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType); 5661 return getConstantGEP(VMContext, Entry, 0, 0); 5662 } 5663 5664 // FIXME: Merge into a single cstring creation function. 5665 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) { 5666 llvm::GlobalVariable *&Entry = PropertyNames[Ident]; 5667 if (!Entry) 5668 Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName); 5669 return getConstantGEP(VMContext, Entry, 0, 0); 5670 } 5671 5672 // FIXME: Merge into a single cstring creation function. 5673 // FIXME: This Decl should be more precise. 5674 llvm::Constant * 5675 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD, 5676 const Decl *Container) { 5677 std::string TypeStr = 5678 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container); 5679 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr)); 5680 } 5681 5682 void CGObjCMac::FinishModule() { 5683 EmitModuleInfo(); 5684 5685 // Emit the dummy bodies for any protocols which were referenced but 5686 // never defined. 5687 for (auto &entry : Protocols) { 5688 llvm::GlobalVariable *global = entry.second; 5689 if (global->hasInitializer()) 5690 continue; 5691 5692 ConstantInitBuilder builder(CGM); 5693 auto values = builder.beginStruct(ObjCTypes.ProtocolTy); 5694 values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy); 5695 values.add(GetClassName(entry.first->getName())); 5696 values.addNullPointer(ObjCTypes.ProtocolListPtrTy); 5697 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy); 5698 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy); 5699 values.finishAndSetAsInitializer(global); 5700 CGM.addCompilerUsedGlobal(global); 5701 } 5702 5703 // Add assembler directives to add lazy undefined symbol references 5704 // for classes which are referenced but not defined. This is 5705 // important for correct linker interaction. 5706 // 5707 // FIXME: It would be nice if we had an LLVM construct for this. 5708 if ((!LazySymbols.empty() || !DefinedSymbols.empty()) && 5709 CGM.getTriple().isOSBinFormatMachO()) { 5710 SmallString<256> Asm; 5711 Asm += CGM.getModule().getModuleInlineAsm(); 5712 if (!Asm.empty() && Asm.back() != '\n') 5713 Asm += '\n'; 5714 5715 llvm::raw_svector_ostream OS(Asm); 5716 for (const auto *Sym : DefinedSymbols) 5717 OS << "\t.objc_class_name_" << Sym->getName() << "=0\n" 5718 << "\t.globl .objc_class_name_" << Sym->getName() << "\n"; 5719 for (const auto *Sym : LazySymbols) 5720 OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n"; 5721 for (const auto &Category : DefinedCategoryNames) 5722 OS << "\t.objc_category_name_" << Category << "=0\n" 5723 << "\t.globl .objc_category_name_" << Category << "\n"; 5724 5725 CGM.getModule().setModuleInlineAsm(OS.str()); 5726 } 5727 } 5728 5729 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm) 5730 : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr), 5731 ObjCEmptyVtableVar(nullptr) { 5732 ObjCABI = 2; 5733 } 5734 5735 /* *** */ 5736 5737 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm) 5738 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr) 5739 { 5740 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 5741 ASTContext &Ctx = CGM.getContext(); 5742 5743 ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy)); 5744 IntTy = CGM.IntTy; 5745 LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy)); 5746 Int8PtrTy = CGM.Int8PtrTy; 5747 Int8PtrPtrTy = CGM.Int8PtrPtrTy; 5748 5749 // arm64 targets use "int" ivar offset variables. All others, 5750 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets. 5751 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64) 5752 IvarOffsetVarTy = IntTy; 5753 else 5754 IvarOffsetVarTy = LongTy; 5755 5756 ObjectPtrTy = 5757 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType())); 5758 PtrObjectPtrTy = 5759 llvm::PointerType::getUnqual(ObjectPtrTy); 5760 SelectorPtrTy = 5761 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType())); 5762 5763 // I'm not sure I like this. The implicit coordination is a bit 5764 // gross. We should solve this in a reasonable fashion because this 5765 // is a pretty common task (match some runtime data structure with 5766 // an LLVM data structure). 5767 5768 // FIXME: This is leaked. 5769 // FIXME: Merge with rewriter code? 5770 5771 // struct _objc_super { 5772 // id self; 5773 // Class cls; 5774 // } 5775 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct, 5776 Ctx.getTranslationUnitDecl(), 5777 SourceLocation(), SourceLocation(), 5778 &Ctx.Idents.get("_objc_super")); 5779 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), 5780 nullptr, Ctx.getObjCIdType(), nullptr, nullptr, 5781 false, ICIS_NoInit)); 5782 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), 5783 nullptr, Ctx.getObjCClassType(), nullptr, 5784 nullptr, false, ICIS_NoInit)); 5785 RD->completeDefinition(); 5786 5787 SuperCTy = Ctx.getTagDeclType(RD); 5788 SuperPtrCTy = Ctx.getPointerType(SuperCTy); 5789 5790 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy)); 5791 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy); 5792 5793 // struct _prop_t { 5794 // char *name; 5795 // char *attributes; 5796 // } 5797 PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy); 5798 5799 // struct _prop_list_t { 5800 // uint32_t entsize; // sizeof(struct _prop_t) 5801 // uint32_t count_of_properties; 5802 // struct _prop_t prop_list[count_of_properties]; 5803 // } 5804 PropertyListTy = llvm::StructType::create( 5805 "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0)); 5806 // struct _prop_list_t * 5807 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy); 5808 5809 // struct _objc_method { 5810 // SEL _cmd; 5811 // char *method_type; 5812 // char *_imp; 5813 // } 5814 MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy, 5815 Int8PtrTy, Int8PtrTy); 5816 5817 // struct _objc_cache * 5818 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache"); 5819 CachePtrTy = llvm::PointerType::getUnqual(CacheTy); 5820 } 5821 5822 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm) 5823 : ObjCCommonTypesHelper(cgm) { 5824 // struct _objc_method_description { 5825 // SEL name; 5826 // char *types; 5827 // } 5828 MethodDescriptionTy = llvm::StructType::create( 5829 "struct._objc_method_description", SelectorPtrTy, Int8PtrTy); 5830 5831 // struct _objc_method_description_list { 5832 // int count; 5833 // struct _objc_method_description[1]; 5834 // } 5835 MethodDescriptionListTy = 5836 llvm::StructType::create("struct._objc_method_description_list", IntTy, 5837 llvm::ArrayType::get(MethodDescriptionTy, 0)); 5838 5839 // struct _objc_method_description_list * 5840 MethodDescriptionListPtrTy = 5841 llvm::PointerType::getUnqual(MethodDescriptionListTy); 5842 5843 // Protocol description structures 5844 5845 // struct _objc_protocol_extension { 5846 // uint32_t size; // sizeof(struct _objc_protocol_extension) 5847 // struct _objc_method_description_list *optional_instance_methods; 5848 // struct _objc_method_description_list *optional_class_methods; 5849 // struct _objc_property_list *instance_properties; 5850 // const char ** extendedMethodTypes; 5851 // struct _objc_property_list *class_properties; 5852 // } 5853 ProtocolExtensionTy = llvm::StructType::create( 5854 "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy, 5855 MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy, 5856 PropertyListPtrTy); 5857 5858 // struct _objc_protocol_extension * 5859 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy); 5860 5861 // Handle recursive construction of Protocol and ProtocolList types 5862 5863 ProtocolTy = 5864 llvm::StructType::create(VMContext, "struct._objc_protocol"); 5865 5866 ProtocolListTy = 5867 llvm::StructType::create(VMContext, "struct._objc_protocol_list"); 5868 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy, 5869 llvm::ArrayType::get(ProtocolTy, 0)); 5870 5871 // struct _objc_protocol { 5872 // struct _objc_protocol_extension *isa; 5873 // char *protocol_name; 5874 // struct _objc_protocol **_objc_protocol_list; 5875 // struct _objc_method_description_list *instance_methods; 5876 // struct _objc_method_description_list *class_methods; 5877 // } 5878 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy, 5879 llvm::PointerType::getUnqual(ProtocolListTy), 5880 MethodDescriptionListPtrTy, MethodDescriptionListPtrTy); 5881 5882 // struct _objc_protocol_list * 5883 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy); 5884 5885 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy); 5886 5887 // Class description structures 5888 5889 // struct _objc_ivar { 5890 // char *ivar_name; 5891 // char *ivar_type; 5892 // int ivar_offset; 5893 // } 5894 IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy, 5895 IntTy); 5896 5897 // struct _objc_ivar_list * 5898 IvarListTy = 5899 llvm::StructType::create(VMContext, "struct._objc_ivar_list"); 5900 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy); 5901 5902 // struct _objc_method_list * 5903 MethodListTy = 5904 llvm::StructType::create(VMContext, "struct._objc_method_list"); 5905 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy); 5906 5907 // struct _objc_class_extension * 5908 ClassExtensionTy = llvm::StructType::create( 5909 "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy); 5910 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy); 5911 5912 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class"); 5913 5914 // struct _objc_class { 5915 // Class isa; 5916 // Class super_class; 5917 // char *name; 5918 // long version; 5919 // long info; 5920 // long instance_size; 5921 // struct _objc_ivar_list *ivars; 5922 // struct _objc_method_list *methods; 5923 // struct _objc_cache *cache; 5924 // struct _objc_protocol_list *protocols; 5925 // char *ivar_layout; 5926 // struct _objc_class_ext *ext; 5927 // }; 5928 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy), 5929 llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy, 5930 LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy, 5931 ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy); 5932 5933 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy); 5934 5935 // struct _objc_category { 5936 // char *category_name; 5937 // char *class_name; 5938 // struct _objc_method_list *instance_method; 5939 // struct _objc_method_list *class_method; 5940 // struct _objc_protocol_list *protocols; 5941 // uint32_t size; // sizeof(struct _objc_category) 5942 // struct _objc_property_list *instance_properties;// category's @property 5943 // struct _objc_property_list *class_properties; 5944 // } 5945 CategoryTy = llvm::StructType::create( 5946 "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy, 5947 MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy, 5948 PropertyListPtrTy); 5949 5950 // Global metadata structures 5951 5952 // struct _objc_symtab { 5953 // long sel_ref_cnt; 5954 // SEL *refs; 5955 // short cls_def_cnt; 5956 // short cat_def_cnt; 5957 // char *defs[cls_def_cnt + cat_def_cnt]; 5958 // } 5959 SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy, 5960 SelectorPtrTy, ShortTy, ShortTy, 5961 llvm::ArrayType::get(Int8PtrTy, 0)); 5962 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy); 5963 5964 // struct _objc_module { 5965 // long version; 5966 // long size; // sizeof(struct _objc_module) 5967 // char *name; 5968 // struct _objc_symtab* symtab; 5969 // } 5970 ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy, 5971 Int8PtrTy, SymtabPtrTy); 5972 5973 // FIXME: This is the size of the setjmp buffer and should be target 5974 // specific. 18 is what's used on 32-bit X86. 5975 uint64_t SetJmpBufferSize = 18; 5976 5977 // Exceptions 5978 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4); 5979 5980 ExceptionDataTy = llvm::StructType::create( 5981 "struct._objc_exception_data", 5982 llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy); 5983 } 5984 5985 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm) 5986 : ObjCCommonTypesHelper(cgm) { 5987 // struct _method_list_t { 5988 // uint32_t entsize; // sizeof(struct _objc_method) 5989 // uint32_t method_count; 5990 // struct _objc_method method_list[method_count]; 5991 // } 5992 MethodListnfABITy = 5993 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy, 5994 llvm::ArrayType::get(MethodTy, 0)); 5995 // struct method_list_t * 5996 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy); 5997 5998 // struct _protocol_t { 5999 // id isa; // NULL 6000 // const char * const protocol_name; 6001 // const struct _protocol_list_t * protocol_list; // super protocols 6002 // const struct method_list_t * const instance_methods; 6003 // const struct method_list_t * const class_methods; 6004 // const struct method_list_t *optionalInstanceMethods; 6005 // const struct method_list_t *optionalClassMethods; 6006 // const struct _prop_list_t * properties; 6007 // const uint32_t size; // sizeof(struct _protocol_t) 6008 // const uint32_t flags; // = 0 6009 // const char ** extendedMethodTypes; 6010 // const char *demangledName; 6011 // const struct _prop_list_t * class_properties; 6012 // } 6013 6014 // Holder for struct _protocol_list_t * 6015 ProtocolListnfABITy = 6016 llvm::StructType::create(VMContext, "struct._objc_protocol_list"); 6017 6018 ProtocolnfABITy = llvm::StructType::create( 6019 "struct._protocol_t", ObjectPtrTy, Int8PtrTy, 6020 llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy, 6021 MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy, 6022 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy, 6023 PropertyListPtrTy); 6024 6025 // struct _protocol_t* 6026 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy); 6027 6028 // struct _protocol_list_t { 6029 // long protocol_count; // Note, this is 32/64 bit 6030 // struct _protocol_t *[protocol_count]; 6031 // } 6032 ProtocolListnfABITy->setBody(LongTy, 6033 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0)); 6034 6035 // struct _objc_protocol_list* 6036 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy); 6037 6038 // struct _ivar_t { 6039 // unsigned [long] int *offset; // pointer to ivar offset location 6040 // char *name; 6041 // char *type; 6042 // uint32_t alignment; 6043 // uint32_t size; 6044 // } 6045 IvarnfABITy = llvm::StructType::create( 6046 "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy), 6047 Int8PtrTy, Int8PtrTy, IntTy, IntTy); 6048 6049 // struct _ivar_list_t { 6050 // uint32 entsize; // sizeof(struct _ivar_t) 6051 // uint32 count; 6052 // struct _iver_t list[count]; 6053 // } 6054 IvarListnfABITy = 6055 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy, 6056 llvm::ArrayType::get(IvarnfABITy, 0)); 6057 6058 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy); 6059 6060 // struct _class_ro_t { 6061 // uint32_t const flags; 6062 // uint32_t const instanceStart; 6063 // uint32_t const instanceSize; 6064 // uint32_t const reserved; // only when building for 64bit targets 6065 // const uint8_t * const ivarLayout; 6066 // const char *const name; 6067 // const struct _method_list_t * const baseMethods; 6068 // const struct _objc_protocol_list *const baseProtocols; 6069 // const struct _ivar_list_t *const ivars; 6070 // const uint8_t * const weakIvarLayout; 6071 // const struct _prop_list_t * const properties; 6072 // } 6073 6074 // FIXME. Add 'reserved' field in 64bit abi mode! 6075 ClassRonfABITy = llvm::StructType::create( 6076 "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy, 6077 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy, 6078 Int8PtrTy, PropertyListPtrTy); 6079 6080 // ImpnfABITy - LLVM for id (*)(id, SEL, ...) 6081 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; 6082 ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false) 6083 ->getPointerTo(); 6084 6085 // struct _class_t { 6086 // struct _class_t *isa; 6087 // struct _class_t * const superclass; 6088 // void *cache; 6089 // IMP *vtable; 6090 // struct class_ro_t *ro; 6091 // } 6092 6093 ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t"); 6094 ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy), 6095 llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy, 6096 llvm::PointerType::getUnqual(ImpnfABITy), 6097 llvm::PointerType::getUnqual(ClassRonfABITy)); 6098 6099 // LLVM for struct _class_t * 6100 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy); 6101 6102 // struct _category_t { 6103 // const char * const name; 6104 // struct _class_t *const cls; 6105 // const struct _method_list_t * const instance_methods; 6106 // const struct _method_list_t * const class_methods; 6107 // const struct _protocol_list_t * const protocols; 6108 // const struct _prop_list_t * const properties; 6109 // const struct _prop_list_t * const class_properties; 6110 // const uint32_t size; 6111 // } 6112 CategorynfABITy = llvm::StructType::create( 6113 "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy, 6114 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy, 6115 PropertyListPtrTy, IntTy); 6116 6117 // New types for nonfragile abi messaging. 6118 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 6119 ASTContext &Ctx = CGM.getContext(); 6120 6121 // MessageRefTy - LLVM for: 6122 // struct _message_ref_t { 6123 // IMP messenger; 6124 // SEL name; 6125 // }; 6126 6127 // First the clang type for struct _message_ref_t 6128 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct, 6129 Ctx.getTranslationUnitDecl(), 6130 SourceLocation(), SourceLocation(), 6131 &Ctx.Idents.get("_message_ref_t")); 6132 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), 6133 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false, 6134 ICIS_NoInit)); 6135 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), 6136 nullptr, Ctx.getObjCSelType(), nullptr, nullptr, 6137 false, ICIS_NoInit)); 6138 RD->completeDefinition(); 6139 6140 MessageRefCTy = Ctx.getTagDeclType(RD); 6141 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy); 6142 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy)); 6143 6144 // MessageRefPtrTy - LLVM for struct _message_ref_t* 6145 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy); 6146 6147 // SuperMessageRefTy - LLVM for: 6148 // struct _super_message_ref_t { 6149 // SUPER_IMP messenger; 6150 // SEL name; 6151 // }; 6152 SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t", 6153 ImpnfABITy, SelectorPtrTy); 6154 6155 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t* 6156 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy); 6157 6158 6159 // struct objc_typeinfo { 6160 // const void** vtable; // objc_ehtype_vtable + 2 6161 // const char* name; // c++ typeinfo string 6162 // Class cls; 6163 // }; 6164 EHTypeTy = llvm::StructType::create("struct._objc_typeinfo", 6165 llvm::PointerType::getUnqual(Int8PtrTy), 6166 Int8PtrTy, ClassnfABIPtrTy); 6167 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy); 6168 } 6169 6170 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() { 6171 FinishNonFragileABIModule(); 6172 6173 return nullptr; 6174 } 6175 6176 void CGObjCNonFragileABIMac::AddModuleClassList( 6177 ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName, 6178 StringRef SectionName) { 6179 unsigned NumClasses = Container.size(); 6180 6181 if (!NumClasses) 6182 return; 6183 6184 SmallVector<llvm::Constant*, 8> Symbols(NumClasses); 6185 for (unsigned i=0; i<NumClasses; i++) 6186 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i], 6187 ObjCTypes.Int8PtrTy); 6188 llvm::Constant *Init = 6189 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy, 6190 Symbols.size()), 6191 Symbols); 6192 6193 // Section name is obtained by calling GetSectionName, which returns 6194 // sections in the __DATA segment on MachO. 6195 assert((!CGM.getTriple().isOSBinFormatMachO() || 6196 SectionName.startswith("__DATA")) && 6197 "SectionName expected to start with __DATA on MachO"); 6198 llvm::GlobalVariable *GV = new llvm::GlobalVariable( 6199 CGM.getModule(), Init->getType(), false, 6200 llvm::GlobalValue::PrivateLinkage, Init, SymbolName); 6201 GV->setAlignment( 6202 llvm::Align(CGM.getDataLayout().getABITypeAlignment(Init->getType()))); 6203 GV->setSection(SectionName); 6204 CGM.addCompilerUsedGlobal(GV); 6205 } 6206 6207 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() { 6208 // nonfragile abi has no module definition. 6209 6210 // Build list of all implemented class addresses in array 6211 // L_OBJC_LABEL_CLASS_$. 6212 6213 for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) { 6214 const ObjCInterfaceDecl *ID = ImplementedClasses[i]; 6215 assert(ID); 6216 if (ObjCImplementationDecl *IMP = ID->getImplementation()) 6217 // We are implementing a weak imported interface. Give it external linkage 6218 if (ID->isWeakImported() && !IMP->isWeakImported()) { 6219 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage); 6220 DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage); 6221 } 6222 } 6223 6224 AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$", 6225 GetSectionName("__objc_classlist", 6226 "regular,no_dead_strip")); 6227 6228 AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$", 6229 GetSectionName("__objc_nlclslist", 6230 "regular,no_dead_strip")); 6231 6232 // Build list of all implemented category addresses in array 6233 // L_OBJC_LABEL_CATEGORY_$. 6234 AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$", 6235 GetSectionName("__objc_catlist", 6236 "regular,no_dead_strip")); 6237 AddModuleClassList(DefinedStubCategories, "OBJC_LABEL_STUB_CATEGORY_$", 6238 GetSectionName("__objc_catlist2", 6239 "regular,no_dead_strip")); 6240 AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$", 6241 GetSectionName("__objc_nlcatlist", 6242 "regular,no_dead_strip")); 6243 6244 EmitImageInfo(); 6245 } 6246 6247 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of 6248 /// VTableDispatchMethods; false otherwise. What this means is that 6249 /// except for the 19 selectors in the list, we generate 32bit-style 6250 /// message dispatch call for all the rest. 6251 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) { 6252 // At various points we've experimented with using vtable-based 6253 // dispatch for all methods. 6254 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) { 6255 case CodeGenOptions::Legacy: 6256 return false; 6257 case CodeGenOptions::NonLegacy: 6258 return true; 6259 case CodeGenOptions::Mixed: 6260 break; 6261 } 6262 6263 // If so, see whether this selector is in the white-list of things which must 6264 // use the new dispatch convention. We lazily build a dense set for this. 6265 if (VTableDispatchMethods.empty()) { 6266 VTableDispatchMethods.insert(GetNullarySelector("alloc")); 6267 VTableDispatchMethods.insert(GetNullarySelector("class")); 6268 VTableDispatchMethods.insert(GetNullarySelector("self")); 6269 VTableDispatchMethods.insert(GetNullarySelector("isFlipped")); 6270 VTableDispatchMethods.insert(GetNullarySelector("length")); 6271 VTableDispatchMethods.insert(GetNullarySelector("count")); 6272 6273 // These are vtable-based if GC is disabled. 6274 // Optimistically use vtable dispatch for hybrid compiles. 6275 if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) { 6276 VTableDispatchMethods.insert(GetNullarySelector("retain")); 6277 VTableDispatchMethods.insert(GetNullarySelector("release")); 6278 VTableDispatchMethods.insert(GetNullarySelector("autorelease")); 6279 } 6280 6281 VTableDispatchMethods.insert(GetUnarySelector("allocWithZone")); 6282 VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass")); 6283 VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector")); 6284 VTableDispatchMethods.insert(GetUnarySelector("objectForKey")); 6285 VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex")); 6286 VTableDispatchMethods.insert(GetUnarySelector("isEqualToString")); 6287 VTableDispatchMethods.insert(GetUnarySelector("isEqual")); 6288 6289 // These are vtable-based if GC is enabled. 6290 // Optimistically use vtable dispatch for hybrid compiles. 6291 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) { 6292 VTableDispatchMethods.insert(GetNullarySelector("hash")); 6293 VTableDispatchMethods.insert(GetUnarySelector("addObject")); 6294 6295 // "countByEnumeratingWithState:objects:count" 6296 IdentifierInfo *KeyIdents[] = { 6297 &CGM.getContext().Idents.get("countByEnumeratingWithState"), 6298 &CGM.getContext().Idents.get("objects"), 6299 &CGM.getContext().Idents.get("count") 6300 }; 6301 VTableDispatchMethods.insert( 6302 CGM.getContext().Selectors.getSelector(3, KeyIdents)); 6303 } 6304 } 6305 6306 return VTableDispatchMethods.count(Sel); 6307 } 6308 6309 /// BuildClassRoTInitializer - generate meta-data for: 6310 /// struct _class_ro_t { 6311 /// uint32_t const flags; 6312 /// uint32_t const instanceStart; 6313 /// uint32_t const instanceSize; 6314 /// uint32_t const reserved; // only when building for 64bit targets 6315 /// const uint8_t * const ivarLayout; 6316 /// const char *const name; 6317 /// const struct _method_list_t * const baseMethods; 6318 /// const struct _protocol_list_t *const baseProtocols; 6319 /// const struct _ivar_list_t *const ivars; 6320 /// const uint8_t * const weakIvarLayout; 6321 /// const struct _prop_list_t * const properties; 6322 /// } 6323 /// 6324 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer( 6325 unsigned flags, 6326 unsigned InstanceStart, 6327 unsigned InstanceSize, 6328 const ObjCImplementationDecl *ID) { 6329 std::string ClassName = std::string(ID->getObjCRuntimeNameAsString()); 6330 6331 CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart); 6332 CharUnits endInstance = CharUnits::fromQuantity(InstanceSize); 6333 6334 bool hasMRCWeak = false; 6335 if (CGM.getLangOpts().ObjCAutoRefCount) 6336 flags |= NonFragileABI_Class_CompiledByARC; 6337 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID))) 6338 flags |= NonFragileABI_Class_HasMRCWeakIvars; 6339 6340 ConstantInitBuilder builder(CGM); 6341 auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy); 6342 6343 values.addInt(ObjCTypes.IntTy, flags); 6344 values.addInt(ObjCTypes.IntTy, InstanceStart); 6345 values.addInt(ObjCTypes.IntTy, InstanceSize); 6346 values.add((flags & NonFragileABI_Class_Meta) 6347 ? GetIvarLayoutName(nullptr, ObjCTypes) 6348 : BuildStrongIvarLayout(ID, beginInstance, endInstance)); 6349 values.add(GetClassName(ID->getObjCRuntimeNameAsString())); 6350 6351 // const struct _method_list_t * const baseMethods; 6352 SmallVector<const ObjCMethodDecl*, 16> methods; 6353 if (flags & NonFragileABI_Class_Meta) { 6354 for (const auto *MD : ID->class_methods()) 6355 if (!MD->isDirectMethod()) 6356 methods.push_back(MD); 6357 } else { 6358 for (const auto *MD : ID->instance_methods()) 6359 if (!MD->isDirectMethod()) 6360 methods.push_back(MD); 6361 } 6362 6363 values.add(emitMethodList(ID->getObjCRuntimeNameAsString(), 6364 (flags & NonFragileABI_Class_Meta) 6365 ? MethodListType::ClassMethods 6366 : MethodListType::InstanceMethods, 6367 methods)); 6368 6369 const ObjCInterfaceDecl *OID = ID->getClassInterface(); 6370 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer"); 6371 values.add(EmitProtocolList("_OBJC_CLASS_PROTOCOLS_$_" 6372 + OID->getObjCRuntimeNameAsString(), 6373 OID->all_referenced_protocol_begin(), 6374 OID->all_referenced_protocol_end())); 6375 6376 if (flags & NonFragileABI_Class_Meta) { 6377 values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy); 6378 values.add(GetIvarLayoutName(nullptr, ObjCTypes)); 6379 values.add(EmitPropertyList( 6380 "_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(), 6381 ID, ID->getClassInterface(), ObjCTypes, true)); 6382 } else { 6383 values.add(EmitIvarList(ID)); 6384 values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak)); 6385 values.add(EmitPropertyList( 6386 "_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(), 6387 ID, ID->getClassInterface(), ObjCTypes, false)); 6388 } 6389 6390 llvm::SmallString<64> roLabel; 6391 llvm::raw_svector_ostream(roLabel) 6392 << ((flags & NonFragileABI_Class_Meta) ? "_OBJC_METACLASS_RO_$_" 6393 : "_OBJC_CLASS_RO_$_") 6394 << ClassName; 6395 6396 return finishAndCreateGlobal(values, roLabel, CGM); 6397 } 6398 6399 /// Build the metaclass object for a class. 6400 /// 6401 /// struct _class_t { 6402 /// struct _class_t *isa; 6403 /// struct _class_t * const superclass; 6404 /// void *cache; 6405 /// IMP *vtable; 6406 /// struct class_ro_t *ro; 6407 /// } 6408 /// 6409 llvm::GlobalVariable * 6410 CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI, 6411 bool isMetaclass, 6412 llvm::Constant *IsAGV, 6413 llvm::Constant *SuperClassGV, 6414 llvm::Constant *ClassRoGV, 6415 bool HiddenVisibility) { 6416 ConstantInitBuilder builder(CGM); 6417 auto values = builder.beginStruct(ObjCTypes.ClassnfABITy); 6418 values.add(IsAGV); 6419 if (SuperClassGV) { 6420 values.add(SuperClassGV); 6421 } else { 6422 values.addNullPointer(ObjCTypes.ClassnfABIPtrTy); 6423 } 6424 values.add(ObjCEmptyCacheVar); 6425 values.add(ObjCEmptyVtableVar); 6426 values.add(ClassRoGV); 6427 6428 llvm::GlobalVariable *GV = 6429 cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition)); 6430 values.finishAndSetAsInitializer(GV); 6431 6432 if (CGM.getTriple().isOSBinFormatMachO()) 6433 GV->setSection("__DATA, __objc_data"); 6434 GV->setAlignment(llvm::Align( 6435 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy))); 6436 if (!CGM.getTriple().isOSBinFormatCOFF()) 6437 if (HiddenVisibility) 6438 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 6439 return GV; 6440 } 6441 6442 bool CGObjCNonFragileABIMac::ImplementationIsNonLazy( 6443 const ObjCImplDecl *OD) const { 6444 return OD->getClassMethod(GetNullarySelector("load")) != nullptr || 6445 OD->getClassInterface()->hasAttr<ObjCNonLazyClassAttr>() || 6446 OD->hasAttr<ObjCNonLazyClassAttr>(); 6447 } 6448 6449 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID, 6450 uint32_t &InstanceStart, 6451 uint32_t &InstanceSize) { 6452 const ASTRecordLayout &RL = 6453 CGM.getContext().getASTObjCImplementationLayout(OID); 6454 6455 // InstanceSize is really instance end. 6456 InstanceSize = RL.getDataSize().getQuantity(); 6457 6458 // If there are no fields, the start is the same as the end. 6459 if (!RL.getFieldCount()) 6460 InstanceStart = InstanceSize; 6461 else 6462 InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth(); 6463 } 6464 6465 static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM, 6466 StringRef Name) { 6467 IdentifierInfo &II = CGM.getContext().Idents.get(Name); 6468 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); 6469 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); 6470 6471 const VarDecl *VD = nullptr; 6472 for (const auto *Result : DC->lookup(&II)) 6473 if ((VD = dyn_cast<VarDecl>(Result))) 6474 break; 6475 6476 if (!VD) 6477 return llvm::GlobalValue::DLLImportStorageClass; 6478 if (VD->hasAttr<DLLExportAttr>()) 6479 return llvm::GlobalValue::DLLExportStorageClass; 6480 if (VD->hasAttr<DLLImportAttr>()) 6481 return llvm::GlobalValue::DLLImportStorageClass; 6482 return llvm::GlobalValue::DefaultStorageClass; 6483 } 6484 6485 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) { 6486 if (!ObjCEmptyCacheVar) { 6487 ObjCEmptyCacheVar = 6488 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false, 6489 llvm::GlobalValue::ExternalLinkage, nullptr, 6490 "_objc_empty_cache"); 6491 if (CGM.getTriple().isOSBinFormatCOFF()) 6492 ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache")); 6493 6494 // Only OS X with deployment version <10.9 use the empty vtable symbol 6495 const llvm::Triple &Triple = CGM.getTarget().getTriple(); 6496 if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9)) 6497 ObjCEmptyVtableVar = 6498 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false, 6499 llvm::GlobalValue::ExternalLinkage, nullptr, 6500 "_objc_empty_vtable"); 6501 else 6502 ObjCEmptyVtableVar = 6503 llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo()); 6504 } 6505 6506 // FIXME: Is this correct (that meta class size is never computed)? 6507 uint32_t InstanceStart = 6508 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy); 6509 uint32_t InstanceSize = InstanceStart; 6510 uint32_t flags = NonFragileABI_Class_Meta; 6511 6512 llvm::Constant *SuperClassGV, *IsAGV; 6513 6514 const auto *CI = ID->getClassInterface(); 6515 assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0"); 6516 6517 // Build the flags for the metaclass. 6518 bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF()) 6519 ? !CI->hasAttr<DLLExportAttr>() 6520 : CI->getVisibility() == HiddenVisibility; 6521 if (classIsHidden) 6522 flags |= NonFragileABI_Class_Hidden; 6523 6524 // FIXME: why is this flag set on the metaclass? 6525 // ObjC metaclasses have no fields and don't really get constructed. 6526 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) { 6527 flags |= NonFragileABI_Class_HasCXXStructors; 6528 if (!ID->hasNonZeroConstructors()) 6529 flags |= NonFragileABI_Class_HasCXXDestructorOnly; 6530 } 6531 6532 if (!CI->getSuperClass()) { 6533 // class is root 6534 flags |= NonFragileABI_Class_Root; 6535 6536 SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition); 6537 IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition); 6538 } else { 6539 // Has a root. Current class is not a root. 6540 const ObjCInterfaceDecl *Root = ID->getClassInterface(); 6541 while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) 6542 Root = Super; 6543 6544 const auto *Super = CI->getSuperClass(); 6545 IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition); 6546 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition); 6547 } 6548 6549 llvm::GlobalVariable *CLASS_RO_GV = 6550 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID); 6551 6552 llvm::GlobalVariable *MetaTClass = 6553 BuildClassObject(CI, /*metaclass*/ true, 6554 IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden); 6555 CGM.setGVProperties(MetaTClass, CI); 6556 DefinedMetaClasses.push_back(MetaTClass); 6557 6558 // Metadata for the class 6559 flags = 0; 6560 if (classIsHidden) 6561 flags |= NonFragileABI_Class_Hidden; 6562 6563 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) { 6564 flags |= NonFragileABI_Class_HasCXXStructors; 6565 6566 // Set a flag to enable a runtime optimization when a class has 6567 // fields that require destruction but which don't require 6568 // anything except zero-initialization during construction. This 6569 // is most notably true of __strong and __weak types, but you can 6570 // also imagine there being C++ types with non-trivial default 6571 // constructors that merely set all fields to null. 6572 if (!ID->hasNonZeroConstructors()) 6573 flags |= NonFragileABI_Class_HasCXXDestructorOnly; 6574 } 6575 6576 if (hasObjCExceptionAttribute(CGM.getContext(), CI)) 6577 flags |= NonFragileABI_Class_Exception; 6578 6579 if (!CI->getSuperClass()) { 6580 flags |= NonFragileABI_Class_Root; 6581 SuperClassGV = nullptr; 6582 } else { 6583 // Has a root. Current class is not a root. 6584 const auto *Super = CI->getSuperClass(); 6585 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition); 6586 } 6587 6588 GetClassSizeInfo(ID, InstanceStart, InstanceSize); 6589 CLASS_RO_GV = 6590 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID); 6591 6592 llvm::GlobalVariable *ClassMD = 6593 BuildClassObject(CI, /*metaclass*/ false, 6594 MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden); 6595 CGM.setGVProperties(ClassMD, CI); 6596 DefinedClasses.push_back(ClassMD); 6597 ImplementedClasses.push_back(CI); 6598 6599 // Determine if this class is also "non-lazy". 6600 if (ImplementationIsNonLazy(ID)) 6601 DefinedNonLazyClasses.push_back(ClassMD); 6602 6603 // Force the definition of the EHType if necessary. 6604 if (flags & NonFragileABI_Class_Exception) 6605 (void) GetInterfaceEHType(CI, ForDefinition); 6606 // Make sure method definition entries are all clear for next implementation. 6607 MethodDefinitions.clear(); 6608 } 6609 6610 /// GenerateProtocolRef - This routine is called to generate code for 6611 /// a protocol reference expression; as in: 6612 /// @code 6613 /// @protocol(Proto1); 6614 /// @endcode 6615 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1 6616 /// which will hold address of the protocol meta-data. 6617 /// 6618 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF, 6619 const ObjCProtocolDecl *PD) { 6620 6621 // This routine is called for @protocol only. So, we must build definition 6622 // of protocol's meta-data (not a reference to it!) 6623 assert(!PD->isNonRuntimeProtocol() && 6624 "attempting to get a protocol ref to a static protocol."); 6625 llvm::Constant *Init = 6626 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD), 6627 ObjCTypes.getExternalProtocolPtrTy()); 6628 6629 std::string ProtocolName("_OBJC_PROTOCOL_REFERENCE_$_"); 6630 ProtocolName += PD->getObjCRuntimeNameAsString(); 6631 6632 CharUnits Align = CGF.getPointerAlign(); 6633 6634 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName); 6635 if (PTGV) 6636 return CGF.Builder.CreateAlignedLoad(PTGV->getValueType(), PTGV, Align); 6637 PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false, 6638 llvm::GlobalValue::WeakAnyLinkage, Init, 6639 ProtocolName); 6640 PTGV->setSection(GetSectionName("__objc_protorefs", 6641 "coalesced,no_dead_strip")); 6642 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 6643 PTGV->setAlignment(Align.getAsAlign()); 6644 if (!CGM.getTriple().isOSBinFormatMachO()) 6645 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName)); 6646 CGM.addUsedGlobal(PTGV); 6647 return CGF.Builder.CreateAlignedLoad(PTGV->getValueType(), PTGV, Align); 6648 } 6649 6650 /// GenerateCategory - Build metadata for a category implementation. 6651 /// struct _category_t { 6652 /// const char * const name; 6653 /// struct _class_t *const cls; 6654 /// const struct _method_list_t * const instance_methods; 6655 /// const struct _method_list_t * const class_methods; 6656 /// const struct _protocol_list_t * const protocols; 6657 /// const struct _prop_list_t * const properties; 6658 /// const struct _prop_list_t * const class_properties; 6659 /// const uint32_t size; 6660 /// } 6661 /// 6662 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) { 6663 const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); 6664 const char *Prefix = "_OBJC_$_CATEGORY_"; 6665 6666 llvm::SmallString<64> ExtCatName(Prefix); 6667 ExtCatName += Interface->getObjCRuntimeNameAsString(); 6668 ExtCatName += "_$_"; 6669 ExtCatName += OCD->getNameAsString(); 6670 6671 ConstantInitBuilder builder(CGM); 6672 auto values = builder.beginStruct(ObjCTypes.CategorynfABITy); 6673 values.add(GetClassName(OCD->getIdentifier()->getName())); 6674 // meta-class entry symbol 6675 values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition)); 6676 std::string listName = 6677 (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str(); 6678 6679 SmallVector<const ObjCMethodDecl *, 16> instanceMethods; 6680 SmallVector<const ObjCMethodDecl *, 8> classMethods; 6681 for (const auto *MD : OCD->methods()) { 6682 if (MD->isDirectMethod()) 6683 continue; 6684 if (MD->isInstanceMethod()) { 6685 instanceMethods.push_back(MD); 6686 } else { 6687 classMethods.push_back(MD); 6688 } 6689 } 6690 6691 auto instanceMethodList = emitMethodList( 6692 listName, MethodListType::CategoryInstanceMethods, instanceMethods); 6693 auto classMethodList = emitMethodList( 6694 listName, MethodListType::CategoryClassMethods, classMethods); 6695 values.add(instanceMethodList); 6696 values.add(classMethodList); 6697 // Keep track of whether we have actual metadata to emit. 6698 bool isEmptyCategory = 6699 instanceMethodList->isNullValue() && classMethodList->isNullValue(); 6700 6701 const ObjCCategoryDecl *Category = 6702 Interface->FindCategoryDeclaration(OCD->getIdentifier()); 6703 if (Category) { 6704 SmallString<256> ExtName; 6705 llvm::raw_svector_ostream(ExtName) 6706 << Interface->getObjCRuntimeNameAsString() << "_$_" << OCD->getName(); 6707 auto protocolList = 6708 EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_" + 6709 Interface->getObjCRuntimeNameAsString() + "_$_" + 6710 Category->getName(), 6711 Category->protocol_begin(), Category->protocol_end()); 6712 auto propertyList = EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(), 6713 OCD, Category, ObjCTypes, false); 6714 auto classPropertyList = 6715 EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(), OCD, 6716 Category, ObjCTypes, true); 6717 values.add(protocolList); 6718 values.add(propertyList); 6719 values.add(classPropertyList); 6720 isEmptyCategory &= protocolList->isNullValue() && 6721 propertyList->isNullValue() && 6722 classPropertyList->isNullValue(); 6723 } else { 6724 values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy); 6725 values.addNullPointer(ObjCTypes.PropertyListPtrTy); 6726 values.addNullPointer(ObjCTypes.PropertyListPtrTy); 6727 } 6728 6729 if (isEmptyCategory) { 6730 // Empty category, don't emit any metadata. 6731 values.abandon(); 6732 MethodDefinitions.clear(); 6733 return; 6734 } 6735 6736 unsigned Size = 6737 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy); 6738 values.addInt(ObjCTypes.IntTy, Size); 6739 6740 llvm::GlobalVariable *GCATV = 6741 finishAndCreateGlobal(values, ExtCatName.str(), CGM); 6742 CGM.addCompilerUsedGlobal(GCATV); 6743 if (Interface->hasAttr<ObjCClassStubAttr>()) 6744 DefinedStubCategories.push_back(GCATV); 6745 else 6746 DefinedCategories.push_back(GCATV); 6747 6748 // Determine if this category is also "non-lazy". 6749 if (ImplementationIsNonLazy(OCD)) 6750 DefinedNonLazyCategories.push_back(GCATV); 6751 // method definition entries must be clear for next implementation. 6752 MethodDefinitions.clear(); 6753 } 6754 6755 /// emitMethodConstant - Return a struct objc_method constant. If 6756 /// forProtocol is true, the implementation will be null; otherwise, 6757 /// the method must have a definition registered with the runtime. 6758 /// 6759 /// struct _objc_method { 6760 /// SEL _cmd; 6761 /// char *method_type; 6762 /// char *_imp; 6763 /// } 6764 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder, 6765 const ObjCMethodDecl *MD, 6766 bool forProtocol) { 6767 auto method = builder.beginStruct(ObjCTypes.MethodTy); 6768 method.addBitCast(GetMethodVarName(MD->getSelector()), 6769 ObjCTypes.SelectorPtrTy); 6770 method.add(GetMethodVarType(MD)); 6771 6772 if (forProtocol) { 6773 // Protocol methods have no implementation. So, this entry is always NULL. 6774 method.addNullPointer(ObjCTypes.Int8PtrTy); 6775 } else { 6776 llvm::Function *fn = GetMethodDefinition(MD); 6777 assert(fn && "no definition for method?"); 6778 method.addBitCast(fn, ObjCTypes.Int8PtrTy); 6779 } 6780 6781 method.finishAndAddTo(builder); 6782 } 6783 6784 /// Build meta-data for method declarations. 6785 /// 6786 /// struct _method_list_t { 6787 /// uint32_t entsize; // sizeof(struct _objc_method) 6788 /// uint32_t method_count; 6789 /// struct _objc_method method_list[method_count]; 6790 /// } 6791 /// 6792 llvm::Constant * 6793 CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind, 6794 ArrayRef<const ObjCMethodDecl *> methods) { 6795 // Return null for empty list. 6796 if (methods.empty()) 6797 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy); 6798 6799 StringRef prefix; 6800 bool forProtocol; 6801 switch (kind) { 6802 case MethodListType::CategoryInstanceMethods: 6803 prefix = "_OBJC_$_CATEGORY_INSTANCE_METHODS_"; 6804 forProtocol = false; 6805 break; 6806 case MethodListType::CategoryClassMethods: 6807 prefix = "_OBJC_$_CATEGORY_CLASS_METHODS_"; 6808 forProtocol = false; 6809 break; 6810 case MethodListType::InstanceMethods: 6811 prefix = "_OBJC_$_INSTANCE_METHODS_"; 6812 forProtocol = false; 6813 break; 6814 case MethodListType::ClassMethods: 6815 prefix = "_OBJC_$_CLASS_METHODS_"; 6816 forProtocol = false; 6817 break; 6818 6819 case MethodListType::ProtocolInstanceMethods: 6820 prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_"; 6821 forProtocol = true; 6822 break; 6823 case MethodListType::ProtocolClassMethods: 6824 prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_"; 6825 forProtocol = true; 6826 break; 6827 case MethodListType::OptionalProtocolInstanceMethods: 6828 prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_"; 6829 forProtocol = true; 6830 break; 6831 case MethodListType::OptionalProtocolClassMethods: 6832 prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_"; 6833 forProtocol = true; 6834 break; 6835 } 6836 6837 ConstantInitBuilder builder(CGM); 6838 auto values = builder.beginStruct(); 6839 6840 // sizeof(struct _objc_method) 6841 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy); 6842 values.addInt(ObjCTypes.IntTy, Size); 6843 // method_count 6844 values.addInt(ObjCTypes.IntTy, methods.size()); 6845 auto methodArray = values.beginArray(ObjCTypes.MethodTy); 6846 for (auto MD : methods) 6847 emitMethodConstant(methodArray, MD, forProtocol); 6848 methodArray.finishAndAddTo(values); 6849 6850 llvm::GlobalVariable *GV = finishAndCreateGlobal(values, prefix + name, CGM); 6851 CGM.addCompilerUsedGlobal(GV); 6852 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy); 6853 } 6854 6855 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for 6856 /// the given ivar. 6857 llvm::GlobalVariable * 6858 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID, 6859 const ObjCIvarDecl *Ivar) { 6860 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface(); 6861 llvm::SmallString<64> Name("OBJC_IVAR_$_"); 6862 Name += Container->getObjCRuntimeNameAsString(); 6863 Name += "."; 6864 Name += Ivar->getName(); 6865 llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name); 6866 if (!IvarOffsetGV) { 6867 IvarOffsetGV = 6868 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy, 6869 false, llvm::GlobalValue::ExternalLinkage, 6870 nullptr, Name.str()); 6871 if (CGM.getTriple().isOSBinFormatCOFF()) { 6872 bool IsPrivateOrPackage = 6873 Ivar->getAccessControl() == ObjCIvarDecl::Private || 6874 Ivar->getAccessControl() == ObjCIvarDecl::Package; 6875 6876 const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface(); 6877 6878 if (ContainingID->hasAttr<DLLImportAttr>()) 6879 IvarOffsetGV 6880 ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 6881 else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage) 6882 IvarOffsetGV 6883 ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 6884 } 6885 } 6886 return IvarOffsetGV; 6887 } 6888 6889 llvm::Constant * 6890 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID, 6891 const ObjCIvarDecl *Ivar, 6892 unsigned long int Offset) { 6893 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar); 6894 IvarOffsetGV->setInitializer( 6895 llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset)); 6896 IvarOffsetGV->setAlignment(llvm::Align( 6897 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy))); 6898 6899 if (!CGM.getTriple().isOSBinFormatCOFF()) { 6900 // FIXME: This matches gcc, but shouldn't the visibility be set on the use 6901 // as well (i.e., in ObjCIvarOffsetVariable). 6902 if (Ivar->getAccessControl() == ObjCIvarDecl::Private || 6903 Ivar->getAccessControl() == ObjCIvarDecl::Package || 6904 ID->getVisibility() == HiddenVisibility) 6905 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 6906 else 6907 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility); 6908 } 6909 6910 // If ID's layout is known, then make the global constant. This serves as a 6911 // useful assertion: we'll never use this variable to calculate ivar offsets, 6912 // so if the runtime tries to patch it then we should crash. 6913 if (isClassLayoutKnownStatically(ID)) 6914 IvarOffsetGV->setConstant(true); 6915 6916 if (CGM.getTriple().isOSBinFormatMachO()) 6917 IvarOffsetGV->setSection("__DATA, __objc_ivar"); 6918 return IvarOffsetGV; 6919 } 6920 6921 /// EmitIvarList - Emit the ivar list for the given 6922 /// implementation. The return value has type 6923 /// IvarListnfABIPtrTy. 6924 /// struct _ivar_t { 6925 /// unsigned [long] int *offset; // pointer to ivar offset location 6926 /// char *name; 6927 /// char *type; 6928 /// uint32_t alignment; 6929 /// uint32_t size; 6930 /// } 6931 /// struct _ivar_list_t { 6932 /// uint32 entsize; // sizeof(struct _ivar_t) 6933 /// uint32 count; 6934 /// struct _iver_t list[count]; 6935 /// } 6936 /// 6937 6938 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList( 6939 const ObjCImplementationDecl *ID) { 6940 6941 ConstantInitBuilder builder(CGM); 6942 auto ivarList = builder.beginStruct(); 6943 ivarList.addInt(ObjCTypes.IntTy, 6944 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy)); 6945 auto ivarCountSlot = ivarList.addPlaceholder(); 6946 auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy); 6947 6948 const ObjCInterfaceDecl *OID = ID->getClassInterface(); 6949 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface"); 6950 6951 // FIXME. Consolidate this with similar code in GenerateClass. 6952 6953 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin(); 6954 IVD; IVD = IVD->getNextIvar()) { 6955 // Ignore unnamed bit-fields. 6956 if (!IVD->getDeclName()) 6957 continue; 6958 6959 auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy); 6960 ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD, 6961 ComputeIvarBaseOffset(CGM, ID, IVD))); 6962 ivar.add(GetMethodVarName(IVD->getIdentifier())); 6963 ivar.add(GetMethodVarType(IVD)); 6964 llvm::Type *FieldTy = 6965 CGM.getTypes().ConvertTypeForMem(IVD->getType()); 6966 unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy); 6967 unsigned Align = CGM.getContext().getPreferredTypeAlign( 6968 IVD->getType().getTypePtr()) >> 3; 6969 Align = llvm::Log2_32(Align); 6970 ivar.addInt(ObjCTypes.IntTy, Align); 6971 // NOTE. Size of a bitfield does not match gcc's, because of the 6972 // way bitfields are treated special in each. But I am told that 6973 // 'size' for bitfield ivars is ignored by the runtime so it does 6974 // not matter. If it matters, there is enough info to get the 6975 // bitfield right! 6976 ivar.addInt(ObjCTypes.IntTy, Size); 6977 ivar.finishAndAddTo(ivars); 6978 } 6979 // Return null for empty list. 6980 if (ivars.empty()) { 6981 ivars.abandon(); 6982 ivarList.abandon(); 6983 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy); 6984 } 6985 6986 auto ivarCount = ivars.size(); 6987 ivars.finishAndAddTo(ivarList); 6988 ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount); 6989 6990 const char *Prefix = "_OBJC_$_INSTANCE_VARIABLES_"; 6991 llvm::GlobalVariable *GV = finishAndCreateGlobal( 6992 ivarList, Prefix + OID->getObjCRuntimeNameAsString(), CGM); 6993 CGM.addCompilerUsedGlobal(GV); 6994 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy); 6995 } 6996 6997 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef( 6998 const ObjCProtocolDecl *PD) { 6999 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 7000 7001 assert(!PD->isNonRuntimeProtocol() && 7002 "attempting to GetOrEmit a non-runtime protocol"); 7003 if (!Entry) { 7004 // We use the initializer as a marker of whether this is a forward 7005 // reference or not. At module finalization we add the empty 7006 // contents for protocols which were referenced but never defined. 7007 llvm::SmallString<64> Protocol; 7008 llvm::raw_svector_ostream(Protocol) << "_OBJC_PROTOCOL_$_" 7009 << PD->getObjCRuntimeNameAsString(); 7010 7011 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy, 7012 false, llvm::GlobalValue::ExternalLinkage, 7013 nullptr, Protocol); 7014 if (!CGM.getTriple().isOSBinFormatMachO()) 7015 Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol)); 7016 } 7017 7018 return Entry; 7019 } 7020 7021 /// GetOrEmitProtocol - Generate the protocol meta-data: 7022 /// @code 7023 /// struct _protocol_t { 7024 /// id isa; // NULL 7025 /// const char * const protocol_name; 7026 /// const struct _protocol_list_t * protocol_list; // super protocols 7027 /// const struct method_list_t * const instance_methods; 7028 /// const struct method_list_t * const class_methods; 7029 /// const struct method_list_t *optionalInstanceMethods; 7030 /// const struct method_list_t *optionalClassMethods; 7031 /// const struct _prop_list_t * properties; 7032 /// const uint32_t size; // sizeof(struct _protocol_t) 7033 /// const uint32_t flags; // = 0 7034 /// const char ** extendedMethodTypes; 7035 /// const char *demangledName; 7036 /// const struct _prop_list_t * class_properties; 7037 /// } 7038 /// @endcode 7039 /// 7040 7041 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol( 7042 const ObjCProtocolDecl *PD) { 7043 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()]; 7044 7045 // Early exit if a defining object has already been generated. 7046 if (Entry && Entry->hasInitializer()) 7047 return Entry; 7048 7049 // Use the protocol definition, if there is one. 7050 assert(PD->hasDefinition() && 7051 "emitting protocol metadata without definition"); 7052 PD = PD->getDefinition(); 7053 7054 auto methodLists = ProtocolMethodLists::get(PD); 7055 7056 ConstantInitBuilder builder(CGM); 7057 auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy); 7058 7059 // isa is NULL 7060 values.addNullPointer(ObjCTypes.ObjectPtrTy); 7061 values.add(GetClassName(PD->getObjCRuntimeNameAsString())); 7062 values.add(EmitProtocolList("_OBJC_$_PROTOCOL_REFS_" 7063 + PD->getObjCRuntimeNameAsString(), 7064 PD->protocol_begin(), 7065 PD->protocol_end())); 7066 values.add(methodLists.emitMethodList(this, PD, 7067 ProtocolMethodLists::RequiredInstanceMethods)); 7068 values.add(methodLists.emitMethodList(this, PD, 7069 ProtocolMethodLists::RequiredClassMethods)); 7070 values.add(methodLists.emitMethodList(this, PD, 7071 ProtocolMethodLists::OptionalInstanceMethods)); 7072 values.add(methodLists.emitMethodList(this, PD, 7073 ProtocolMethodLists::OptionalClassMethods)); 7074 values.add(EmitPropertyList( 7075 "_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(), 7076 nullptr, PD, ObjCTypes, false)); 7077 uint32_t Size = 7078 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy); 7079 values.addInt(ObjCTypes.IntTy, Size); 7080 values.addInt(ObjCTypes.IntTy, 0); 7081 values.add(EmitProtocolMethodTypes("_OBJC_$_PROTOCOL_METHOD_TYPES_" 7082 + PD->getObjCRuntimeNameAsString(), 7083 methodLists.emitExtendedTypesArray(this), 7084 ObjCTypes)); 7085 7086 // const char *demangledName; 7087 values.addNullPointer(ObjCTypes.Int8PtrTy); 7088 7089 values.add(EmitPropertyList( 7090 "_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(), 7091 nullptr, PD, ObjCTypes, true)); 7092 7093 if (Entry) { 7094 // Already created, fix the linkage and update the initializer. 7095 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage); 7096 values.finishAndSetAsInitializer(Entry); 7097 } else { 7098 llvm::SmallString<64> symbolName; 7099 llvm::raw_svector_ostream(symbolName) 7100 << "_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString(); 7101 7102 Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(), 7103 /*constant*/ false, 7104 llvm::GlobalValue::WeakAnyLinkage); 7105 if (!CGM.getTriple().isOSBinFormatMachO()) 7106 Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName)); 7107 7108 Protocols[PD->getIdentifier()] = Entry; 7109 } 7110 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility); 7111 CGM.addUsedGlobal(Entry); 7112 7113 // Use this protocol meta-data to build protocol list table in section 7114 // __DATA, __objc_protolist 7115 llvm::SmallString<64> ProtocolRef; 7116 llvm::raw_svector_ostream(ProtocolRef) << "_OBJC_LABEL_PROTOCOL_$_" 7117 << PD->getObjCRuntimeNameAsString(); 7118 7119 llvm::GlobalVariable *PTGV = 7120 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy, 7121 false, llvm::GlobalValue::WeakAnyLinkage, Entry, 7122 ProtocolRef); 7123 if (!CGM.getTriple().isOSBinFormatMachO()) 7124 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef)); 7125 PTGV->setAlignment(llvm::Align( 7126 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy))); 7127 PTGV->setSection(GetSectionName("__objc_protolist", 7128 "coalesced,no_dead_strip")); 7129 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 7130 CGM.addUsedGlobal(PTGV); 7131 return Entry; 7132 } 7133 7134 /// EmitProtocolList - Generate protocol list meta-data: 7135 /// @code 7136 /// struct _protocol_list_t { 7137 /// long protocol_count; // Note, this is 32/64 bit 7138 /// struct _protocol_t[protocol_count]; 7139 /// } 7140 /// @endcode 7141 /// 7142 llvm::Constant * 7143 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name, 7144 ObjCProtocolDecl::protocol_iterator begin, 7145 ObjCProtocolDecl::protocol_iterator end) { 7146 // Just return null for empty protocol lists 7147 auto Protocols = GetRuntimeProtocolList(begin, end); 7148 if (Protocols.empty()) 7149 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy); 7150 7151 SmallVector<llvm::Constant *, 16> ProtocolRefs; 7152 ProtocolRefs.reserve(Protocols.size()); 7153 7154 for (const auto *PD : Protocols) 7155 ProtocolRefs.push_back(GetProtocolRef(PD)); 7156 7157 // If all of the protocols in the protocol list are objc_non_runtime_protocol 7158 // just return null 7159 if (ProtocolRefs.size() == 0) 7160 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy); 7161 7162 // FIXME: We shouldn't need to do this lookup here, should we? 7163 SmallString<256> TmpName; 7164 Name.toVector(TmpName); 7165 llvm::GlobalVariable *GV = 7166 CGM.getModule().getGlobalVariable(TmpName.str(), true); 7167 if (GV) 7168 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy); 7169 7170 ConstantInitBuilder builder(CGM); 7171 auto values = builder.beginStruct(); 7172 auto countSlot = values.addPlaceholder(); 7173 7174 // A null-terminated array of protocols. 7175 auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy); 7176 for (auto const &proto : ProtocolRefs) 7177 array.add(proto); 7178 auto count = array.size(); 7179 array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy); 7180 7181 array.finishAndAddTo(values); 7182 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count); 7183 7184 GV = finishAndCreateGlobal(values, Name, CGM); 7185 CGM.addCompilerUsedGlobal(GV); 7186 return llvm::ConstantExpr::getBitCast(GV, 7187 ObjCTypes.ProtocolListnfABIPtrTy); 7188 } 7189 7190 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference. 7191 /// This code gen. amounts to generating code for: 7192 /// @code 7193 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar; 7194 /// @encode 7195 /// 7196 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar( 7197 CodeGen::CodeGenFunction &CGF, 7198 QualType ObjectTy, 7199 llvm::Value *BaseValue, 7200 const ObjCIvarDecl *Ivar, 7201 unsigned CVRQualifiers) { 7202 ObjCInterfaceDecl *ID = ObjectTy->castAs<ObjCObjectType>()->getInterface(); 7203 llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar); 7204 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, 7205 Offset); 7206 } 7207 7208 llvm::Value * 7209 CGObjCNonFragileABIMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 7210 const ObjCInterfaceDecl *Interface, 7211 const ObjCIvarDecl *Ivar) { 7212 llvm::Value *IvarOffsetValue; 7213 if (isClassLayoutKnownStatically(Interface)) { 7214 IvarOffsetValue = llvm::ConstantInt::get( 7215 ObjCTypes.IvarOffsetVarTy, 7216 ComputeIvarBaseOffset(CGM, Interface->getImplementation(), Ivar)); 7217 } else { 7218 llvm::GlobalVariable *GV = ObjCIvarOffsetVariable(Interface, Ivar); 7219 IvarOffsetValue = 7220 CGF.Builder.CreateAlignedLoad(GV->getValueType(), GV, 7221 CGF.getSizeAlign(), "ivar"); 7222 if (IsIvarOffsetKnownIdempotent(CGF, Ivar)) 7223 cast<llvm::LoadInst>(IvarOffsetValue) 7224 ->setMetadata(CGM.getModule().getMDKindID("invariant.load"), 7225 llvm::MDNode::get(VMContext, None)); 7226 } 7227 7228 // This could be 32bit int or 64bit integer depending on the architecture. 7229 // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value 7230 // as this is what caller always expects. 7231 if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy) 7232 IvarOffsetValue = CGF.Builder.CreateIntCast( 7233 IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv"); 7234 return IvarOffsetValue; 7235 } 7236 7237 static void appendSelectorForMessageRefTable(std::string &buffer, 7238 Selector selector) { 7239 if (selector.isUnarySelector()) { 7240 buffer += selector.getNameForSlot(0); 7241 return; 7242 } 7243 7244 for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) { 7245 buffer += selector.getNameForSlot(i); 7246 buffer += '_'; 7247 } 7248 } 7249 7250 /// Emit a "vtable" message send. We emit a weak hidden-visibility 7251 /// struct, initially containing the selector pointer and a pointer to 7252 /// a "fixup" variant of the appropriate objc_msgSend. To call, we 7253 /// load and call the function pointer, passing the address of the 7254 /// struct as the second parameter. The runtime determines whether 7255 /// the selector is currently emitted using vtable dispatch; if so, it 7256 /// substitutes a stub function which simply tail-calls through the 7257 /// appropriate vtable slot, and if not, it substitues a stub function 7258 /// which tail-calls objc_msgSend. Both stubs adjust the selector 7259 /// argument to correctly point to the selector. 7260 RValue 7261 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF, 7262 ReturnValueSlot returnSlot, 7263 QualType resultType, 7264 Selector selector, 7265 llvm::Value *arg0, 7266 QualType arg0Type, 7267 bool isSuper, 7268 const CallArgList &formalArgs, 7269 const ObjCMethodDecl *method) { 7270 // Compute the actual arguments. 7271 CallArgList args; 7272 7273 // First argument: the receiver / super-call structure. 7274 if (!isSuper) 7275 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy); 7276 args.add(RValue::get(arg0), arg0Type); 7277 7278 // Second argument: a pointer to the message ref structure. Leave 7279 // the actual argument value blank for now. 7280 args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy); 7281 7282 args.insert(args.end(), formalArgs.begin(), formalArgs.end()); 7283 7284 MessageSendInfo MSI = getMessageSendInfo(method, resultType, args); 7285 7286 NullReturnState nullReturn; 7287 7288 // Find the function to call and the mangled name for the message 7289 // ref structure. Using a different mangled name wouldn't actually 7290 // be a problem; it would just be a waste. 7291 // 7292 // The runtime currently never uses vtable dispatch for anything 7293 // except normal, non-super message-sends. 7294 // FIXME: don't use this for that. 7295 llvm::FunctionCallee fn = nullptr; 7296 std::string messageRefName("_"); 7297 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) { 7298 if (isSuper) { 7299 fn = ObjCTypes.getMessageSendSuper2StretFixupFn(); 7300 messageRefName += "objc_msgSendSuper2_stret_fixup"; 7301 } else { 7302 nullReturn.init(CGF, arg0); 7303 fn = ObjCTypes.getMessageSendStretFixupFn(); 7304 messageRefName += "objc_msgSend_stret_fixup"; 7305 } 7306 } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) { 7307 fn = ObjCTypes.getMessageSendFpretFixupFn(); 7308 messageRefName += "objc_msgSend_fpret_fixup"; 7309 } else { 7310 if (isSuper) { 7311 fn = ObjCTypes.getMessageSendSuper2FixupFn(); 7312 messageRefName += "objc_msgSendSuper2_fixup"; 7313 } else { 7314 fn = ObjCTypes.getMessageSendFixupFn(); 7315 messageRefName += "objc_msgSend_fixup"; 7316 } 7317 } 7318 assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend"); 7319 messageRefName += '_'; 7320 7321 // Append the selector name, except use underscores anywhere we 7322 // would have used colons. 7323 appendSelectorForMessageRefTable(messageRefName, selector); 7324 7325 llvm::GlobalVariable *messageRef 7326 = CGM.getModule().getGlobalVariable(messageRefName); 7327 if (!messageRef) { 7328 // Build the message ref structure. 7329 ConstantInitBuilder builder(CGM); 7330 auto values = builder.beginStruct(); 7331 values.add(cast<llvm::Constant>(fn.getCallee())); 7332 values.add(GetMethodVarName(selector)); 7333 messageRef = values.finishAndCreateGlobal(messageRefName, 7334 CharUnits::fromQuantity(16), 7335 /*constant*/ false, 7336 llvm::GlobalValue::WeakAnyLinkage); 7337 messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility); 7338 messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced")); 7339 } 7340 7341 bool requiresnullCheck = false; 7342 if (CGM.getLangOpts().ObjCAutoRefCount && method) 7343 for (const auto *ParamDecl : method->parameters()) { 7344 if (ParamDecl->isDestroyedInCallee()) { 7345 if (!nullReturn.NullBB) 7346 nullReturn.init(CGF, arg0); 7347 requiresnullCheck = true; 7348 break; 7349 } 7350 } 7351 7352 Address mref = 7353 Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy), 7354 ObjCTypes.MessageRefTy, CGF.getPointerAlign()); 7355 7356 // Update the message ref argument. 7357 args[1].setRValue(RValue::get(mref.getPointer())); 7358 7359 // Load the function to call from the message ref table. 7360 Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0); 7361 llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn"); 7362 7363 calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType); 7364 CGCallee callee(CGCalleeInfo(), calleePtr); 7365 7366 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args); 7367 return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs, 7368 requiresnullCheck ? method : nullptr); 7369 } 7370 7371 /// Generate code for a message send expression in the nonfragile abi. 7372 CodeGen::RValue 7373 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 7374 ReturnValueSlot Return, 7375 QualType ResultType, 7376 Selector Sel, 7377 llvm::Value *Receiver, 7378 const CallArgList &CallArgs, 7379 const ObjCInterfaceDecl *Class, 7380 const ObjCMethodDecl *Method) { 7381 return isVTableDispatchedSelector(Sel) 7382 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel, 7383 Receiver, CGF.getContext().getObjCIdType(), 7384 false, CallArgs, Method) 7385 : EmitMessageSend(CGF, Return, ResultType, Sel, 7386 Receiver, CGF.getContext().getObjCIdType(), 7387 false, CallArgs, Method, Class, ObjCTypes); 7388 } 7389 7390 llvm::Constant * 7391 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID, 7392 bool metaclass, 7393 ForDefinition_t isForDefinition) { 7394 auto prefix = 7395 (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix()); 7396 return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(), 7397 isForDefinition, 7398 ID->isWeakImported(), 7399 !isForDefinition 7400 && CGM.getTriple().isOSBinFormatCOFF() 7401 && ID->hasAttr<DLLImportAttr>()); 7402 } 7403 7404 llvm::Constant * 7405 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name, 7406 ForDefinition_t IsForDefinition, 7407 bool Weak, bool DLLImport) { 7408 llvm::GlobalValue::LinkageTypes L = 7409 Weak ? llvm::GlobalValue::ExternalWeakLinkage 7410 : llvm::GlobalValue::ExternalLinkage; 7411 7412 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name); 7413 if (!GV || GV->getValueType() != ObjCTypes.ClassnfABITy) { 7414 auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L, 7415 nullptr, Name); 7416 7417 if (DLLImport) 7418 NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 7419 7420 if (GV) { 7421 GV->replaceAllUsesWith( 7422 llvm::ConstantExpr::getBitCast(NewGV, GV->getType())); 7423 GV->eraseFromParent(); 7424 } 7425 GV = NewGV; 7426 CGM.getModule().getGlobalList().push_back(GV); 7427 } 7428 7429 assert(GV->getLinkage() == L); 7430 return GV; 7431 } 7432 7433 llvm::Constant * 7434 CGObjCNonFragileABIMac::GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID) { 7435 llvm::Constant *ClassGV = GetClassGlobal(ID, /*metaclass*/ false, 7436 NotForDefinition); 7437 7438 if (!ID->hasAttr<ObjCClassStubAttr>()) 7439 return ClassGV; 7440 7441 ClassGV = llvm::ConstantExpr::getPointerCast(ClassGV, ObjCTypes.Int8PtrTy); 7442 7443 // Stub classes are pointer-aligned. Classrefs pointing at stub classes 7444 // must set the least significant bit set to 1. 7445 auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1); 7446 return llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, ClassGV, Idx); 7447 } 7448 7449 llvm::Value * 7450 CGObjCNonFragileABIMac::EmitLoadOfClassRef(CodeGenFunction &CGF, 7451 const ObjCInterfaceDecl *ID, 7452 llvm::GlobalVariable *Entry) { 7453 if (ID && ID->hasAttr<ObjCClassStubAttr>()) { 7454 // Classrefs pointing at Objective-C stub classes must be loaded by calling 7455 // a special runtime function. 7456 return CGF.EmitRuntimeCall( 7457 ObjCTypes.getLoadClassrefFn(), Entry, "load_classref_result"); 7458 } 7459 7460 CharUnits Align = CGF.getPointerAlign(); 7461 return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry, Align); 7462 } 7463 7464 llvm::Value * 7465 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF, 7466 IdentifierInfo *II, 7467 const ObjCInterfaceDecl *ID) { 7468 llvm::GlobalVariable *&Entry = ClassReferences[II]; 7469 7470 if (!Entry) { 7471 llvm::Constant *ClassGV; 7472 if (ID) { 7473 ClassGV = GetClassGlobalForClassRef(ID); 7474 } else { 7475 ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(), 7476 NotForDefinition); 7477 assert(ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy && 7478 "classref was emitted with the wrong type?"); 7479 } 7480 7481 std::string SectionName = 7482 GetSectionName("__objc_classrefs", "regular,no_dead_strip"); 7483 Entry = new llvm::GlobalVariable( 7484 CGM.getModule(), ClassGV->getType(), false, 7485 getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV, 7486 "OBJC_CLASSLIST_REFERENCES_$_"); 7487 Entry->setAlignment(CGF.getPointerAlign().getAsAlign()); 7488 if (!ID || !ID->hasAttr<ObjCClassStubAttr>()) 7489 Entry->setSection(SectionName); 7490 7491 CGM.addCompilerUsedGlobal(Entry); 7492 } 7493 7494 return EmitLoadOfClassRef(CGF, ID, Entry); 7495 } 7496 7497 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF, 7498 const ObjCInterfaceDecl *ID) { 7499 // If the class has the objc_runtime_visible attribute, we need to 7500 // use the Objective-C runtime to get the class. 7501 if (ID->hasAttr<ObjCRuntimeVisibleAttr>()) 7502 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes); 7503 7504 return EmitClassRefFromId(CGF, ID->getIdentifier(), ID); 7505 } 7506 7507 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef( 7508 CodeGenFunction &CGF) { 7509 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool"); 7510 return EmitClassRefFromId(CGF, II, nullptr); 7511 } 7512 7513 llvm::Value * 7514 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF, 7515 const ObjCInterfaceDecl *ID) { 7516 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()]; 7517 7518 if (!Entry) { 7519 llvm::Constant *ClassGV = GetClassGlobalForClassRef(ID); 7520 std::string SectionName = 7521 GetSectionName("__objc_superrefs", "regular,no_dead_strip"); 7522 Entry = new llvm::GlobalVariable(CGM.getModule(), ClassGV->getType(), false, 7523 llvm::GlobalValue::PrivateLinkage, ClassGV, 7524 "OBJC_CLASSLIST_SUP_REFS_$_"); 7525 Entry->setAlignment(CGF.getPointerAlign().getAsAlign()); 7526 Entry->setSection(SectionName); 7527 CGM.addCompilerUsedGlobal(Entry); 7528 } 7529 7530 return EmitLoadOfClassRef(CGF, ID, Entry); 7531 } 7532 7533 /// EmitMetaClassRef - Return a Value * of the address of _class_t 7534 /// meta-data 7535 /// 7536 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF, 7537 const ObjCInterfaceDecl *ID, 7538 bool Weak) { 7539 CharUnits Align = CGF.getPointerAlign(); 7540 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()]; 7541 if (!Entry) { 7542 auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition); 7543 std::string SectionName = 7544 GetSectionName("__objc_superrefs", "regular,no_dead_strip"); 7545 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy, 7546 false, llvm::GlobalValue::PrivateLinkage, 7547 MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_"); 7548 Entry->setAlignment(Align.getAsAlign()); 7549 Entry->setSection(SectionName); 7550 CGM.addCompilerUsedGlobal(Entry); 7551 } 7552 7553 return CGF.Builder.CreateAlignedLoad(ObjCTypes.ClassnfABIPtrTy, Entry, Align); 7554 } 7555 7556 /// GetClass - Return a reference to the class for the given interface 7557 /// decl. 7558 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF, 7559 const ObjCInterfaceDecl *ID) { 7560 if (ID->isWeakImported()) { 7561 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition); 7562 (void)ClassGV; 7563 assert(!isa<llvm::GlobalVariable>(ClassGV) || 7564 cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage()); 7565 } 7566 7567 return EmitClassRef(CGF, ID); 7568 } 7569 7570 /// Generates a message send where the super is the receiver. This is 7571 /// a message send to self with special delivery semantics indicating 7572 /// which class's method should be called. 7573 CodeGen::RValue 7574 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 7575 ReturnValueSlot Return, 7576 QualType ResultType, 7577 Selector Sel, 7578 const ObjCInterfaceDecl *Class, 7579 bool isCategoryImpl, 7580 llvm::Value *Receiver, 7581 bool IsClassMessage, 7582 const CodeGen::CallArgList &CallArgs, 7583 const ObjCMethodDecl *Method) { 7584 // ... 7585 // Create and init a super structure; this is a (receiver, class) 7586 // pair we will pass to objc_msgSendSuper. 7587 Address ObjCSuper = 7588 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(), 7589 "objc_super"); 7590 7591 llvm::Value *ReceiverAsObject = 7592 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy); 7593 CGF.Builder.CreateStore(ReceiverAsObject, 7594 CGF.Builder.CreateStructGEP(ObjCSuper, 0)); 7595 7596 // If this is a class message the metaclass is passed as the target. 7597 llvm::Value *Target; 7598 if (IsClassMessage) 7599 Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported()); 7600 else 7601 Target = EmitSuperClassRef(CGF, Class); 7602 7603 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and 7604 // ObjCTypes types. 7605 llvm::Type *ClassTy = 7606 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType()); 7607 Target = CGF.Builder.CreateBitCast(Target, ClassTy); 7608 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1)); 7609 7610 return (isVTableDispatchedSelector(Sel)) 7611 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel, 7612 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy, 7613 true, CallArgs, Method) 7614 : EmitMessageSend(CGF, Return, ResultType, Sel, 7615 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy, 7616 true, CallArgs, Method, Class, ObjCTypes); 7617 } 7618 7619 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF, 7620 Selector Sel) { 7621 Address Addr = EmitSelectorAddr(Sel); 7622 7623 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr); 7624 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"), 7625 llvm::MDNode::get(VMContext, None)); 7626 return LI; 7627 } 7628 7629 Address CGObjCNonFragileABIMac::EmitSelectorAddr(Selector Sel) { 7630 llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; 7631 CharUnits Align = CGM.getPointerAlign(); 7632 if (!Entry) { 7633 llvm::Constant *Casted = 7634 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel), 7635 ObjCTypes.SelectorPtrTy); 7636 std::string SectionName = 7637 GetSectionName("__objc_selrefs", "literal_pointers,no_dead_strip"); 7638 Entry = new llvm::GlobalVariable( 7639 CGM.getModule(), ObjCTypes.SelectorPtrTy, false, 7640 getLinkageTypeForObjCMetadata(CGM, SectionName), Casted, 7641 "OBJC_SELECTOR_REFERENCES_"); 7642 Entry->setExternallyInitialized(true); 7643 Entry->setSection(SectionName); 7644 Entry->setAlignment(Align.getAsAlign()); 7645 CGM.addCompilerUsedGlobal(Entry); 7646 } 7647 7648 return Address(Entry, ObjCTypes.SelectorPtrTy, Align); 7649 } 7650 7651 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object. 7652 /// objc_assign_ivar (id src, id *dst, ptrdiff_t) 7653 /// 7654 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 7655 llvm::Value *src, 7656 Address dst, 7657 llvm::Value *ivarOffset) { 7658 llvm::Type * SrcTy = src->getType(); 7659 if (!isa<llvm::PointerType>(SrcTy)) { 7660 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); 7661 assert(Size <= 8 && "does not support size > 8"); 7662 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 7663 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); 7664 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 7665 } 7666 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 7667 llvm::Value *dstVal = 7668 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy); 7669 llvm::Value *args[] = {src, dstVal, ivarOffset}; 7670 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args); 7671 } 7672 7673 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object. 7674 /// objc_assign_strongCast (id src, id *dst) 7675 /// 7676 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign( 7677 CodeGen::CodeGenFunction &CGF, 7678 llvm::Value *src, Address dst) { 7679 llvm::Type * SrcTy = src->getType(); 7680 if (!isa<llvm::PointerType>(SrcTy)) { 7681 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); 7682 assert(Size <= 8 && "does not support size > 8"); 7683 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 7684 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); 7685 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 7686 } 7687 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 7688 llvm::Value *dstVal = 7689 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy); 7690 llvm::Value *args[] = {src, dstVal}; 7691 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(), 7692 args, "weakassign"); 7693 } 7694 7695 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable( 7696 CodeGen::CodeGenFunction &CGF, 7697 Address DestPtr, 7698 Address SrcPtr, 7699 llvm::Value *Size) { 7700 SrcPtr = CGF.Builder.CreateElementBitCast(SrcPtr, CGF.Int8Ty); 7701 DestPtr = CGF.Builder.CreateElementBitCast(DestPtr, CGF.Int8Ty); 7702 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size }; 7703 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args); 7704 } 7705 7706 /// EmitObjCWeakRead - Code gen for loading value of a __weak 7707 /// object: objc_read_weak (id *src) 7708 /// 7709 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead( 7710 CodeGen::CodeGenFunction &CGF, 7711 Address AddrWeakObj) { 7712 llvm::Type *DestTy = AddrWeakObj.getElementType(); 7713 llvm::Value *AddrWeakObjVal = CGF.Builder.CreateBitCast( 7714 AddrWeakObj.getPointer(), ObjCTypes.PtrObjectPtrTy); 7715 llvm::Value *read_weak = 7716 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(), 7717 AddrWeakObjVal, "weakread"); 7718 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); 7719 return read_weak; 7720 } 7721 7722 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object. 7723 /// objc_assign_weak (id src, id *dst) 7724 /// 7725 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 7726 llvm::Value *src, Address dst) { 7727 llvm::Type * SrcTy = src->getType(); 7728 if (!isa<llvm::PointerType>(SrcTy)) { 7729 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); 7730 assert(Size <= 8 && "does not support size > 8"); 7731 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 7732 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); 7733 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 7734 } 7735 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 7736 llvm::Value *dstVal = 7737 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy); 7738 llvm::Value *args[] = {src, dstVal}; 7739 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(), 7740 args, "weakassign"); 7741 } 7742 7743 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object. 7744 /// objc_assign_global (id src, id *dst) 7745 /// 7746 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 7747 llvm::Value *src, Address dst, 7748 bool threadlocal) { 7749 llvm::Type * SrcTy = src->getType(); 7750 if (!isa<llvm::PointerType>(SrcTy)) { 7751 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); 7752 assert(Size <= 8 && "does not support size > 8"); 7753 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 7754 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); 7755 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 7756 } 7757 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 7758 llvm::Value *dstVal = 7759 CGF.Builder.CreateBitCast(dst.getPointer(), ObjCTypes.PtrObjectPtrTy); 7760 llvm::Value *args[] = {src, dstVal}; 7761 if (!threadlocal) 7762 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(), 7763 args, "globalassign"); 7764 else 7765 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(), 7766 args, "threadlocalassign"); 7767 } 7768 7769 void 7770 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 7771 const ObjCAtSynchronizedStmt &S) { 7772 EmitAtSynchronizedStmt(CGF, S, ObjCTypes.getSyncEnterFn(), 7773 ObjCTypes.getSyncExitFn()); 7774 } 7775 7776 llvm::Constant * 7777 CGObjCNonFragileABIMac::GetEHType(QualType T) { 7778 // There's a particular fixed type info for 'id'. 7779 if (T->isObjCIdType() || T->isObjCQualifiedIdType()) { 7780 auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id"); 7781 if (!IDEHType) { 7782 IDEHType = 7783 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false, 7784 llvm::GlobalValue::ExternalLinkage, nullptr, 7785 "OBJC_EHTYPE_id"); 7786 if (CGM.getTriple().isOSBinFormatCOFF()) 7787 IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id")); 7788 } 7789 return IDEHType; 7790 } 7791 7792 // All other types should be Objective-C interface pointer types. 7793 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>(); 7794 assert(PT && "Invalid @catch type."); 7795 7796 const ObjCInterfaceType *IT = PT->getInterfaceType(); 7797 assert(IT && "Invalid @catch type."); 7798 7799 return GetInterfaceEHType(IT->getDecl(), NotForDefinition); 7800 } 7801 7802 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF, 7803 const ObjCAtTryStmt &S) { 7804 EmitTryCatchStmt(CGF, S, ObjCTypes.getObjCBeginCatchFn(), 7805 ObjCTypes.getObjCEndCatchFn(), 7806 ObjCTypes.getExceptionRethrowFn()); 7807 } 7808 7809 /// EmitThrowStmt - Generate code for a throw statement. 7810 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 7811 const ObjCAtThrowStmt &S, 7812 bool ClearInsertionPoint) { 7813 if (const Expr *ThrowExpr = S.getThrowExpr()) { 7814 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr); 7815 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy); 7816 llvm::CallBase *Call = 7817 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception); 7818 Call->setDoesNotReturn(); 7819 } else { 7820 llvm::CallBase *Call = 7821 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn()); 7822 Call->setDoesNotReturn(); 7823 } 7824 7825 CGF.Builder.CreateUnreachable(); 7826 if (ClearInsertionPoint) 7827 CGF.Builder.ClearInsertionPoint(); 7828 } 7829 7830 llvm::Constant * 7831 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID, 7832 ForDefinition_t IsForDefinition) { 7833 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()]; 7834 StringRef ClassName = ID->getObjCRuntimeNameAsString(); 7835 7836 // If we don't need a definition, return the entry if found or check 7837 // if we use an external reference. 7838 if (!IsForDefinition) { 7839 if (Entry) 7840 return Entry; 7841 7842 // If this type (or a super class) has the __objc_exception__ 7843 // attribute, emit an external reference. 7844 if (hasObjCExceptionAttribute(CGM.getContext(), ID)) { 7845 std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str(); 7846 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, 7847 false, llvm::GlobalValue::ExternalLinkage, 7848 nullptr, EHTypeName); 7849 CGM.setGVProperties(Entry, ID); 7850 return Entry; 7851 } 7852 } 7853 7854 // Otherwise we need to either make a new entry or fill in the initializer. 7855 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition"); 7856 7857 std::string VTableName = "objc_ehtype_vtable"; 7858 auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName); 7859 if (!VTableGV) { 7860 VTableGV = 7861 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false, 7862 llvm::GlobalValue::ExternalLinkage, nullptr, 7863 VTableName); 7864 if (CGM.getTriple().isOSBinFormatCOFF()) 7865 VTableGV->setDLLStorageClass(getStorage(CGM, VTableName)); 7866 } 7867 7868 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2); 7869 ConstantInitBuilder builder(CGM); 7870 auto values = builder.beginStruct(ObjCTypes.EHTypeTy); 7871 values.add( 7872 llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(), 7873 VTableGV, VTableIdx)); 7874 values.add(GetClassName(ClassName)); 7875 values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition)); 7876 7877 llvm::GlobalValue::LinkageTypes L = IsForDefinition 7878 ? llvm::GlobalValue::ExternalLinkage 7879 : llvm::GlobalValue::WeakAnyLinkage; 7880 if (Entry) { 7881 values.finishAndSetAsInitializer(Entry); 7882 Entry->setAlignment(CGM.getPointerAlign().getAsAlign()); 7883 } else { 7884 Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName, 7885 CGM.getPointerAlign(), 7886 /*constant*/ false, 7887 L); 7888 if (hasObjCExceptionAttribute(CGM.getContext(), ID)) 7889 CGM.setGVProperties(Entry, ID); 7890 } 7891 assert(Entry->getLinkage() == L); 7892 7893 if (!CGM.getTriple().isOSBinFormatCOFF()) 7894 if (ID->getVisibility() == HiddenVisibility) 7895 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility); 7896 7897 if (IsForDefinition) 7898 if (CGM.getTriple().isOSBinFormatMachO()) 7899 Entry->setSection("__DATA,__objc_const"); 7900 7901 return Entry; 7902 } 7903 7904 /* *** */ 7905 7906 CodeGen::CGObjCRuntime * 7907 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) { 7908 switch (CGM.getLangOpts().ObjCRuntime.getKind()) { 7909 case ObjCRuntime::FragileMacOSX: 7910 return new CGObjCMac(CGM); 7911 7912 case ObjCRuntime::MacOSX: 7913 case ObjCRuntime::iOS: 7914 case ObjCRuntime::WatchOS: 7915 return new CGObjCNonFragileABIMac(CGM); 7916 7917 case ObjCRuntime::GNUstep: 7918 case ObjCRuntime::GCC: 7919 case ObjCRuntime::ObjFW: 7920 llvm_unreachable("these runtimes are not Mac runtimes"); 7921 } 7922 llvm_unreachable("bad runtime"); 7923 } 7924