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