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