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